Xml support

src/core/AutoRest.Core/Model/CodeModel.cs

@@ -182,5 +182,10 @@ public virtual IEnumerable<string> MyReservedNames
         }
 
         public virtual HashSet<string> LocallyUsedNames => null;
+
+        public bool ShouldGenerateXmlSerialization =>
+            Methods.Any(method => 
+                method.RequestContentType == "application/xml" || 
+                (method.ResponseContentTypes?.Any(rct => rct.StartsWith("application/xml")) ?? false));
     }
 }

src/core/AutoRest.Core/Model/IModelType.cs

@@ -51,6 +51,19 @@ public interface IModelType : IParent, IChild
         /// <param name="other">The object to compare with this object.</param>
         /// <returns>true if the specified object is functionally equal to this object; otherwise, false.</returns>
         bool StructurallyEquals(IModelType other);
+
+        XmlProperties XmlProperties { get; set; }
+
+        [JsonIgnore]
+        string XmlName { get; }
+        [JsonIgnore]
+        string XmlNamespace { get; }
+        [JsonIgnore]
+        string XmlPrefix { get; }
+        [JsonIgnore]
+        bool XmlIsWrapped { get; }
+        [JsonIgnore]
+        bool XmlIsAttribute { get; }
     }
 
     /// <summary>
@@ -179,7 +192,19 @@ public virtual bool StructurallyEquals(IModelType other)
         public virtual IEnumerable<IIdentifier> IdentifiersInScope => this.SingleItemConcat(Parent?.IdentifiersInScope);
         [JsonIgnore]
         public virtual IEnumerable<IChild> Children => Enumerable.Empty<IChild>();
+
+        public XmlProperties XmlProperties { get; set; }
 
+        [JsonIgnore]
+        public virtual string XmlName => XmlProperties?.Name ?? Name.RawValue;
+        [JsonIgnore]
+        public string XmlNamespace => XmlProperties?.Namespace;
+        [JsonIgnore]
+        public string XmlPrefix => XmlProperties?.Prefix;
+        [JsonIgnore]
+        public bool XmlIsWrapped => XmlProperties?.Wrapped ?? false;
+        [JsonIgnore]
+        public bool XmlIsAttribute => XmlProperties?.Attribute ?? false;
     }
 
 }

src/core/AutoRest.Core/Model/Method.cs

@@ -225,6 +225,11 @@ public string Summary
         /// </summary>
         public string RequestContentType { get; set; }
 
+        /// <summary>
+        ///  The potential response content types.
+        /// </summary>
+        public string[] ResponseContentTypes { get; set;}
+
         /// <summary>
         /// Gets vendor extensions dictionary.
         /// </summary>

src/core/AutoRest.Core/Model/Property.cs

@@ -91,5 +91,46 @@ public Fixable<string> Summary
         }
 
         public virtual bool IsPolymorphicDiscriminator => true == (Parent as CompositeType)?.BasePolymorphicDiscriminator?.EqualsIgnoreCase(Name.RawValue);
+
+        /// <summary>
+        /// Represents the path for getting to this property when holding the JSON node of the parent object in your hand.
+        /// </summary>
+        public IEnumerable<string> RealPath { get; set; }
+
+        /// <summary>
+        /// Represents the path for getting to this property when holding the XML node of the parent object in your hand.
+        /// </summary>
+        public IEnumerable<string> RealXmlPath
+        {
+            get
+            {
+                // special case: sequence types are usually inlined into parent
+                if (ModelType is SequenceType && !XmlIsWrapped)
+                {
+                    yield break;
+                }
+
+                // special case: inline property (like additional properties and such)
+                if (RealPath?.Any() != true)
+                {
+                    yield break;
+                }
+
+                yield return XmlName;
+            }
+        }
+
+        public XmlProperties XmlProperties { get; set; }
+
+        [JsonIgnore]
+        public string XmlName => XmlProperties?.Name ?? RealPath.FirstOrDefault() ?? Name;
+        [JsonIgnore]
+        public string XmlNamespace => XmlProperties?.Namespace ?? ModelType.XmlNamespace;
+        [JsonIgnore]
+        public string XmlPrefix => XmlProperties?.Prefix ?? ModelType.XmlPrefix;
+        [JsonIgnore]
+        public bool XmlIsWrapped => XmlProperties?.Wrapped ?? ModelType.XmlIsWrapped;
+        [JsonIgnore]
+        public bool XmlIsAttribute => XmlProperties?.Attribute ?? ModelType.XmlIsAttribute;
     }
 }

src/core/AutoRest.Core/Model/SequenceType.cs

@@ -3,6 +3,7 @@
 
 using System.Globalization;
 using Newtonsoft.Json;
+using AutoRest.Core.Utilities;
 
 namespace AutoRest.Core.Model
 {
@@ -28,5 +29,22 @@ public override void Disambiguate()
         /// Gets or sets the element type of the collection.
         /// </summary>
         public virtual IModelType ElementType { get; set; }
+
+        /// <summary>
+        ///  Xml Properties...
+        /// </summary>
+        public XmlProperties ElementXmlProperties { get; set; }
+
+        [JsonIgnore]
+        public override string XmlName => base.XmlName.Else(ElementType.XmlName);
+
+        [JsonIgnore]
+        public string ElementXmlName => ElementXmlProperties?.Name ?? XmlName;
+        [JsonIgnore]
+        public string ElementXmlNamespace => ElementXmlProperties?.Namespace ?? ElementType.XmlNamespace;
+        [JsonIgnore]
+        public string ElementXmlPrefix => ElementXmlProperties?.Prefix ?? ElementType.XmlPrefix;
+        [JsonIgnore]
+        public bool ElementXmlIsWrapped => ElementXmlProperties?.Wrapped ?? ElementType.XmlIsWrapped;
     }
 }

src/core/AutoRest.Core/Model/XmlProperties.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace AutoRest.Core.Model
+{
+    public class XmlProperties
+    {
+        /// <summary>
+        /// Replaces the name of the element/attribute used for the described schema property.
+        /// When defined within the Items Object (items), it will affect the name of the individual XML elements within the list.
+        /// When defined alongside type being array (outside the items), it will affect the wrapping element and only if wrapped is true.
+        /// If wrapped is false, it will be ignored.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The URL of the namespace definition.
+        /// Value SHOULD be in the form of a URL.
+        /// </summary>
+        public string Namespace { get; set; }
+
+        /// <summary>
+        /// The prefix to be used for the name.
+        /// </summary>
+        public string Prefix { get; set; }
+
+        /// <summary>
+        /// Declares whether the property definition translates to an attribute instead of an element.
+        /// </summary>
+        public bool Attribute { get; set; }
+
+        /// <summary>
+        /// MAY be used only for an array definition.
+        /// Signifies whether the array is wrapped (for example, `<books><book/><book/></books>`) or unwrapped (`<book/><book/>`).
+        /// The definition takes effect only when defined alongside type being array (outside the items).
+        /// </summary>
+        public bool Wrapped { get; set; }
+    }
+}

src/core/AutoRest.Extensions/SwaggerExtensions.cs

@@ -37,6 +37,7 @@ public abstract class SwaggerExtensions
         public const string PositionInOperation = "positionInOperation";
         public const string ParameterLocationExtension = "x-ms-parameter-location";
         public const string ExternalExtension = "x-ms-external";
+        public const string HeaderCollectionPrefix = "x-ms-header-collection-prefix";
 
         private static bool hostChecked = false;
 

src/core/AutoRest/Simplify/CSharpSimplifier.cs

@@ -18,18 +18,21 @@ namespace AutoRest.Simplify
     public class CSharpSimplifier
     {
         private static MetadataReference mscorlib;
+        private static MetadataReference newtonsoft;
+        private static MetadataReference xml;
 
         private static MetadataReference Mscorlib
         {
-            get
-            {
-                if (mscorlib == null)
-                {
-                    mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
-                }
+            get {return mscorlib ?? (mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location));}
+        }
 
-                return mscorlib;
-            }
+        private static MetadataReference Xml {
+            get {return xml ?? (xml = MetadataReference.CreateFromFile($"{Path.GetDirectoryName(typeof(object).Assembly.Location)}\\System.Xml.Linq.dll"));}
+        }
+
+        private static MetadataReference Newtonsoft
+        {
+            get {return newtonsoft ?? (newtonsoft = MetadataReference.CreateFromFile(typeof(Newtonsoft.Json.JsonObjectAttribute).Assembly.Location));}
         }
 
         public async Task Run()
@@ -45,17 +48,13 @@ public async Task Run()
             var solution = new AdhocWorkspace().CurrentSolution
                 .AddProject(projectId, "MyProject", "MyProject", LanguageNames.CSharp)
                 .AddMetadataReference(projectId, Mscorlib)
+                .AddMetadataReference(projectId, Xml)
+                .AddMetadataReference(projectId, Newtonsoft)
                 .AddMetadataReference(projectId, AppDomain.CurrentDomain.GetAssemblies()
-                    .Where(
-                        a =>
-                            string.Compare(a.GetName().Name, "Microsoft.Rest.ClientRuntime.Azure",
-                                StringComparison.OrdinalIgnoreCase) == 0)
+                    .Where(a =>string.Compare(a.GetName().Name, "Microsoft.Rest.ClientRuntime.Azure",StringComparison.OrdinalIgnoreCase) == 0)
                     .Select(a => MetadataReference.CreateFromFile(a.Location)).Single())
                 .AddMetadataReference(projectId, AppDomain.CurrentDomain.GetAssemblies()
-                    .Where(
-                        a =>
-                            string.Compare(a.GetName().Name, "Microsoft.Rest.ClientRuntime",
-                                StringComparison.OrdinalIgnoreCase) == 0)
+                    .Where(a =>string.Compare(a.GetName().Name, "Microsoft.Rest.ClientRuntime",StringComparison.OrdinalIgnoreCase) == 0)
                     .Select(a => MetadataReference.CreateFromFile(a.Location)).Single())
                 .AddMetadataReference(projectId, AppDomain.CurrentDomain.GetAssemblies()
                     .Where(a => string.Compare(a.GetName().Name, "System", StringComparison.OrdinalIgnoreCase) == 0)

src/core/AutoRest/project.json

@@ -41,6 +41,7 @@
   },
 
   "dependencies": {
+    "System.Xml.XDocument" : "4.0.0",
     "Newtonsoft.Json": {"version": "[9.0.1,10.0)", "type":"build"},
     "AutoRest.Core": { "target": "project" ,"type":"build"},
     "AutoRest.Swagger": { "target": "project", "type": "build" },

src/dev/AutoRest.Preview/Linting.cs

@@ -91,17 +91,20 @@ public void ProcessMessages(string swagger, IEnumerable<LogMessage> messages)
             {
                 foreach (var message in messages.Where(m => m.Path != null))
                 {
-                    scintilla.IndicatorCurrent = INDICATOR_BASE + (int)message.Severity;
-                    var node = message.Path.SelectNode(doc);
-                    var start = node.Start.Index;
-                    var len = Math.Max(1, node.End.Index - start);
-                    scintilla.IndicatorFillRange(start, len);
-                    highlights.Add(new Highlight
-                    {
-                        Start = start,
-                        End = start + len,
-                        Message = $"{message.Severity}: [{message.Path.XPath}] {message.Message}"
-                    });
+                    try {
+                        scintilla.IndicatorCurrent = INDICATOR_BASE + (int)message.Severity;
+                        var node = message.Path.SelectNode(doc);
+                        var start = node.Start.Index;
+                        var len = Math.Max(1, node.End.Index - start);
+                        scintilla.IndicatorFillRange(start, len);
+                        highlights.Add(new Highlight {
+                            Start = start,
+                            End = start + len,
+                            Message = $"{message.Severity}: [{message.Path.XPath}] {message.Message}"
+                        });
+                    } catch  {
+
+                    }
                 }
             }
         }