Add x-ms-enum's default to SwaggerObject.

global.json

@@ -0,0 +1,5 @@
+{
+  "sdk": {
+    "version": "2.0.0"
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft.azure/autorest.modeler",
-  "version": "1.9.7",
+  "version": "1.9.8",
   "description": "The modeler extension for classic generators in AutoRest.",
   "scripts": {
     "start": "dotnet src/bin/netcoreapp2.0/autorest.modeler.dll --server",

src/Model/SwaggerObject.cs

@@ -9,6 +9,7 @@
 using AutoRest.Modeler.Properties;
 using Newtonsoft.Json;
 using static AutoRest.Core.Utilities.DependencyInjection;
+using Newtonsoft.Json.Linq;
 
 namespace AutoRest.Modeler.Model
 {
@@ -61,6 +62,28 @@ public virtual string Description
         /// </summary>
         public virtual CollectionFormat CollectionFormat { get; set; }
 
+        /// <summary>
+        /// Determines whether the enum should be treated as a constant.
+        /// If the enum contains exactly one value and is a constraint on a
+        /// required parameter or a required property and has modelAsString set to true.
+        /// Value for "modelAsString" is deduced based on the following conditions:
+        /// - xmsEnum extension applied like this: "x-ms-enum": { "modelAsString": true }.
+        /// - xmsEnum extension not applied at all. Then we treat it as if it was applied like above.
+        /// </summary>
+        [JsonIgnore]
+        public bool IsConstant {
+            get
+            {
+                var xmsEnum = Extensions.GetValue<JToken>(Core.Model.XmsExtensions.Enum.Name) as JContainer;
+                var modelAsString = true;
+                if (xmsEnum?["modelAsString"] != null)
+                {
+                    modelAsString = bool.Parse(xmsEnum["modelAsString"].ToString());
+                }
+                return IsRequired && Enum != null && Enum.Count == 1 && modelAsString;
+            }
+        }
+
         /// <summary>
         /// Sets a default value to the parameter.
         /// </summary>

src/Model/SwaggerParameter.cs

@@ -23,9 +23,6 @@ public override bool IsRequired
             set { _isRequired = value; }
         }
 
-        [JsonIgnore]
-        public bool IsConstant => IsRequired && Enum != null && Enum.Count == 1;
-
         /// <summary>
         /// The schema defining the type used for the body parameter.
         /// </summary>

src/ObjectBuilder.cs

@@ -56,9 +56,11 @@ public virtual IModelType BuildServiceType(string serviceTypeName)
             type.XmlProperties = (SwaggerObject as Schema)?.Xml;
             type.Format = SwaggerObject.Format;
             var xMsEnum = SwaggerObject.Extensions.GetValue<JToken>(Core.Model.XmsExtensions.Enum.Name);
-            if ((SwaggerObject.Enum != null || xMsEnum != null) && type.KnownPrimaryType == KnownPrimaryType.String && !(IsSwaggerObjectConstant(SwaggerObject)))
+            if (SwaggerObject.Enum != null && !SwaggerObject.IsConstant)
             {
                 var enumType = New<EnumType>();
+                // Set the underlying type. This helps to determine whether the values in EnumValue are of type string, number, etc.
+                enumType.UnderlyingType = type;
                 if (SwaggerObject.Enum != null)
                 {
                     SwaggerObject.Enum.ForEach(v => enumType.Values.Add(new EnumValue { Name = v, SerializedName = v }));
@@ -68,11 +70,15 @@ public virtual IModelType BuildServiceType(string serviceTypeName)
                     var enumObject = xMsEnum as JContainer;
                     if (enumObject != null)
                     {
-                        enumType.SetName(enumObject["name"].ToString() );
+                        // set the enum name
+                        enumType.SetName(enumObject["name"].ToString());
+
+                        // process modelAsString
                         if (enumObject["modelAsString"] != null)
                         {
                             enumType.ModelAsString = bool.Parse(enumObject["modelAsString"].ToString());
                         }
+
                         var valueOverrides = enumObject["values"] as JArray;
                         if (valueOverrides != null)
                         {
@@ -124,7 +130,18 @@ public virtual IModelType BuildServiceType(string serviceTypeName)
                 else
                 {
                     enumType.ModelAsString = true;
-                    enumType.SetName( string.Empty);
+                    if (SwaggerObject is SwaggerParameter)
+                    {
+                        enumType.SetName((SwaggerObject as SwaggerParameter).Name.ToPascalCase());
+                    }
+                    else
+                    {
+                        // For a model property serviceTypeName is ModelName_PropertyName.
+                        // Hence we set the value after underscore as the name of the enum. 
+                        enumType.SetName(serviceTypeName.Substring(serviceTypeName.IndexOf("_") + 1).ToPascalCase());
+                    }
+
+                    Modeler.CodeModel.Add(enumType);
                 }
                 enumType.XmlProperties = (SwaggerObject as Schema)?.Xml;
                 return enumType;
@@ -193,7 +210,7 @@ public static void PopulateParameter(IVariable parameter, SwaggerObject swaggerO
             parameter.IsRequired = swaggerObject.IsRequired;
             parameter.DefaultValue = swaggerObject.Default;
 
-            if (IsSwaggerObjectConstant(swaggerObject))
+            if (swaggerObject.IsConstant)
             {
                 parameter.DefaultValue = swaggerObject.Enum[0];
                 parameter.IsConstant = true;
@@ -208,11 +225,6 @@ public static void PopulateParameter(IVariable parameter, SwaggerObject swaggerO
             SetConstraints(parameter.Constraints, swaggerObject);
         }
 
-        private static bool IsSwaggerObjectConstant(SwaggerObject swaggerObject)
-        {
-            return (swaggerObject.Enum != null && swaggerObject.Enum.Count == 1 && swaggerObject.IsRequired);
-        }
-
         public static void SetConstraints(Dictionary<Constraint, string> constraints, SwaggerObject swaggerObject)
         {
             if (constraints == null)

src/autorest.modeler.csproj

@@ -61,7 +61,7 @@
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
     <PackageReference Include="YamlDotNet.Signed" Version="4.2.1" />
-    <PackageReference Include="autorest.common" Version="2.2.21" />
+    <PackageReference Include="autorest.common" Version="2.2.22" />
     <!-- <ProjectReference Include="../../autorest.common/src/autorest.common.csproj" /> -->
   </ItemGroup>
 

test/SwaggerModelerTests.cs

@@ -341,7 +341,7 @@ public void TestDataTypes()
             Assert.Equal("Double double", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[5]));
             Assert.Equal("Decimal decimal", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[6]));
             Assert.Equal("String string", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[7]));
-            Assert.Equal("enum color", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[8]));
+            Assert.Equal("Color color", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[8]));
             Assert.Equal("ByteArray byte", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[9]));
             Assert.Equal("Boolean boolean", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[10]));
             Assert.Equal("Date date", CreateCSharpDeclarationString(codeModel.Methods[0].Parameters[11]));
@@ -358,7 +358,7 @@ public void TestDataTypes()
                 new[] { new EnumValue { Name = "red" }, new EnumValue { Name = "blue" }, new EnumValue { Name = "green" } }
                     .ToList());
             Assert.True(variableEnumInPath.ModelAsString);
-            Assert.Empty(variableEnumInPath.Name.RawValue);
+            Assert.Equal("Color", variableEnumInPath.Name.RawValue);
 
             var variableEnumInQuery =
                 codeModel.Methods.First(m => m.Name == "List" && m.Group.IsNullOrEmpty())
@@ -372,7 +372,7 @@ public void TestDataTypes()
                         new EnumValue {Name = "purple"}
                 }.ToList());
             Assert.True(variableEnumInQuery.ModelAsString);
-            Assert.Empty(variableEnumInQuery.Name.RawValue);
+            Assert.Equal("Color1", variableEnumInQuery.Name.RawValue);
 
             var differentEnum =
                 codeModel.Methods.First(m => m.Name == "List" && m.Group == "DiffEnums")
@@ -382,7 +382,7 @@ public void TestDataTypes()
             Assert.Equal(differentEnum.Values,
                 new[] { new EnumValue { Name = "cyan" }, new EnumValue { Name = "yellow" } }.ToList());
             Assert.True(differentEnum.ModelAsString);
-            Assert.Empty(differentEnum.Name.RawValue);
+            Assert.Equal("Color3", differentEnum.Name.RawValue);
 
             var sameEnum =
                 codeModel.Methods.First(m => m.Name == "Get" && m.Group == "SameEnums")
@@ -393,7 +393,7 @@ public void TestDataTypes()
                 new[] { new EnumValue { Name = "blue" }, new EnumValue { Name = "green" }, new EnumValue { Name = "red" } }
                     .ToList());
             Assert.True(sameEnum.ModelAsString);
-            Assert.Empty(sameEnum.Name.RawValue);
+            Assert.Equal("Color21", sameEnum.Name.RawValue);
 
             var modelEnum =
                 codeModel.ModelTypes.First(m => m.Name == "Product")
@@ -404,7 +404,7 @@ public void TestDataTypes()
                 new[] { new EnumValue { Name = "red" }, new EnumValue { Name = "blue" }, new EnumValue { Name = "green" } }
                     .ToList());
             Assert.True(modelEnum.ModelAsString);
-            Assert.Empty(modelEnum.Name.RawValue);
+            Assert.Equal("Color2", modelEnum.Name.RawValue);
 
             var fixedEnum =
                 codeModel.ModelTypes.First(m => m.Name == "Product")
@@ -435,7 +435,7 @@ public void TestDataTypes()
             Assert.Equal("RefColors", refEnum.Name);
 
 
-            Assert.Equal(2, codeModel.EnumTypes.Count);
+            Assert.Equal(7, codeModel.EnumTypes.Count);
             Assert.Equal("Colors", codeModel.EnumTypes.First().Name);
         }
 
@@ -540,12 +540,13 @@ public void TestConstants()
             Assert.Equal("0", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[8].DefaultValue);
 
             Assert.Equal("RefStrEnum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].Name);
-            Assert.Equal("enum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].ModelType.Name);
+            Assert.Equal("RefStrEnum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].ModelType.Name);
             Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].IsConstant);
             Assert.True(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[9].DefaultValue.IsNullOrEmpty());
 
             Assert.Equal("RefIntEnum", codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].Name);
-            Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].ModelType.IsPrimaryType(KnownPrimaryType.Int));
+            Assert.Equal(true, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].ModelType is EnumType);
+            Assert.Equal(true, (codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].ModelType as EnumType).UnderlyingType.IsPrimaryType(KnownPrimaryType.Int));
             Assert.Equal(false, codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].IsConstant);
             Assert.True(codeModel.ModelTypes.First(m => m.Name == "Product").Properties[10].DefaultValue.IsNullOrEmpty());