Merge pull request #142 from microsoft/bugfix/main-graph-gen-tests

bugfix/main graph gen tests

Author: baywet

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.4] - 2021-04-28
+
+### Changed
+
+- Multiple performance improvements for large descriptions
+- Deterministic ordering of properties/methods/indexers/subclasses
+- Deterministic import of sub path request builders
+- Stopped generating phantom indexer methods for TypeScript and Java
+
 ## [0.0.3] - 2021-04-25
 
 ### Added

abstractions/dotnet/src/RequestInfo.cs

@@ -9,8 +9,8 @@ public class RequestInfo
     {
         public Uri URI { get; set; }
         public HttpMethod HttpMethod { get; set; }
-        public IDictionary<string, object> QueryParameters { get; set; } = new Dictionary<string, object>(StringComparer.InvariantCultureIgnoreCase);
-        public IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+        public IDictionary<string, object> QueryParameters { get; set; } = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+        public IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         public Stream Content { get; set; }
         private const string jsonContentType = "application/json";
         private const string binaryContentType = "application/octet-stream";

core/dotnet/src/HttpCore.cs

@@ -131,7 +131,7 @@ private HttpRequestMessage GetRequestMessageFromRequestInfo(RequestInfo requestI
 
             };
             if(requestInfo.Headers?.Any() ?? false)
-                requestInfo.Headers.Where(x => !contentTypeHeaderName.Equals(x.Key, StringComparison.InvariantCultureIgnoreCase)).ToList().ForEach(x => message.Headers.Add(x.Key, x.Value));
+                requestInfo.Headers.Where(x => !contentTypeHeaderName.Equals(x.Key, StringComparison.OrdinalIgnoreCase)).ToList().ForEach(x => message.Headers.Add(x.Key, x.Value));
             if(requestInfo.Content != null) {
                 message.Content = new StreamContent(requestInfo.Content);
                 if(requestInfo?.Headers?.ContainsKey(contentTypeHeaderName) ?? false)

core/dotnet/src/serialization/JsonParseNodeFactory.cs

@@ -11,7 +11,7 @@ public IParseNode GetRootParseNode(string contentType, Stream content)
         {
             if(string.IsNullOrEmpty(contentType))
                 throw new ArgumentNullException(nameof(contentType));
-            else if(!validContentType.Equals(contentType, StringComparison.InvariantCultureIgnoreCase))
+            else if(!validContentType.Equals(contentType, StringComparison.OrdinalIgnoreCase))
                 throw new ArgumentOutOfRangeException($"expected a {validContentType} content type");
 
             _ = content ?? throw new ArgumentNullException(nameof(content));

core/dotnet/src/serialization/JsonSerializationWriterFactory.cs

@@ -7,7 +7,7 @@ public class JsonSerializationWriterFactory : ISerializationWriterFactory {
         public ISerializationWriter GetSerializationWriter(string contentType) {
             if(string.IsNullOrEmpty(contentType))
                 throw new ArgumentNullException(nameof(contentType));
-            else if(!validContentType.Equals(contentType, StringComparison.InvariantCultureIgnoreCase))
+            else if(!validContentType.Equals(contentType, StringComparison.OrdinalIgnoreCase))
                 throw new ArgumentOutOfRangeException($"expected a {validContentType} content type");
 
             return new JsonSerializationWriter();

docs/kiotaabstractions.md

@@ -23,8 +23,8 @@ public class RequestInfo
     {
         public Uri URI { get; set; }
         public HttpMethod HttpMethod { get; set; }
-        public IDictionary<string, object> QueryParameters { get; set; } = new Dictionary<string, object>(StringComparer.InvariantCultureIgnoreCase);
-        public IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+        public IDictionary<string, object> QueryParameters { get; set; } = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+        public IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         public Stream Content { get; set; }
     }
 ```

samples

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 
 namespace Kiota.Builder
@@ -11,20 +13,27 @@ namespace Kiota.Builder
     public class CodeBlock : CodeElement
     {
         public BlockDeclaration StartBlock {get; set;}
-        public List<CodeElement> InnerChildElements {get; set;} = new List<CodeElement>();
+        protected IDictionary<string, CodeElement> InnerChildElements {get; private set;} = new ConcurrentDictionary<string, CodeElement>(StringComparer.OrdinalIgnoreCase);
         public BlockEnd EndBlock {get; set;}
         public CodeBlock(CodeElement parent):base(parent)
         {
             StartBlock = new BlockDeclaration(this);
             EndBlock = new BlockEnd(this);
         }
 
-        public override IList<CodeElement> GetChildElements()
+        public override IEnumerable<CodeElement> GetChildElements(bool innerOnly = false)
         {
-            var elements = new List<CodeElement>(InnerChildElements);
-            elements.Insert(0, StartBlock);
-            elements.Add(EndBlock);
-            return elements;
+            if(innerOnly)
+                return InnerChildElements.Values;
+            else
+                return new CodeElement[] { StartBlock, EndBlock }.Union(InnerChildElements.Values);
+        }
+        public void RemoveChildElement<T>(params T[] elements) where T: CodeElement {
+            if(elements == null) return;
+
+            foreach(var element in elements) {
+                InnerChildElements.Remove(element.Name);
+            }
         }
         public void AddUsing(params CodeUsing[] codeUsings)
         {
@@ -33,24 +42,72 @@ public void AddUsing(params CodeUsing[] codeUsings)
             AddMissingParent(codeUsings);
             StartBlock.Usings.AddRange(codeUsings);
         }
-        public T GetChildElementOfType<T>(Func<T,bool> predicate) where T : CodeElement {
-            if(predicate == null) 
-                throw new ArgumentNullException(nameof(predicate));
-            else if(this is T thisT && predicate(thisT)) 
-                return thisT;
-            else if(this is CodeBlock currentBlock) {
-                if (currentBlock.InnerChildElements.OfType<T>().Any(predicate))
-                    return currentBlock.InnerChildElements.OfType<T>().First(predicate);
-                else if(currentBlock.InnerChildElements.OfType<CodeBlock>().Any())
-                    return currentBlock.InnerChildElements.OfType<CodeBlock>()
-                                                    .Select(x => x.GetChildElementOfType<T>(predicate))
-                                                    .OfType<T>()
-                                                    .FirstOrDefault();
-                else 
-                    return null;
+        protected IEnumerable<T> AddRange<T>(params T[] elements) where T : CodeElement {
+            if(elements == null) return Enumerable.Empty<T>();
+            AddMissingParent(elements);
+            var innerChildElements = InnerChildElements as ConcurrentDictionary<string, CodeElement>; // to avoid calling the non thread-safe extension method
+            var result = new T[elements.Length]; // not using yield return as they'll only get called if the result is assigned
+
+            for(var i = 0; i < elements.Length; i++) {
+                var element = elements[i];
+                var returnedValue = innerChildElements.GetOrAdd(element.Name, element);
+                result[i] = (T)HandleDuplicatedExceptions(innerChildElements, element, returnedValue);
             }
-            else 
-                return null;
+            return result;
+        }
+        private static CodeElement HandleDuplicatedExceptions(ConcurrentDictionary<string, CodeElement> innerChildElements, CodeElement element, CodeElement returnedValue) {
+            var added = returnedValue == element;
+            if(!added && element is CodeMethod currentMethod)
+                if(currentMethod.MethodKind == CodeMethodKind.IndexerBackwardCompatibility &&
+                    returnedValue is CodeProperty cProp &&
+                    cProp.PropertyKind == CodePropertyKind.RequestBuilder) {
+                    // indexer retrofited to method in the parent request builder on the path and conflicting with the collection request builder propeerty
+                    returnedValue = innerChildElements.GetOrAdd($"{element.Name}-indexerbackcompat", element);
+                    added = true;
+                } else if(currentMethod.MethodKind == CodeMethodKind.RequestExecutor ||
+                        currentMethod.MethodKind == CodeMethodKind.RequestGenerator) {
+                    // allows for methods overload
+                    var methodOverloadNameSuffix = currentMethod.Parameters.Any() ? currentMethod.Parameters.Select(x => x.Name).OrderBy(x => x).Aggregate((x, y) => x + y) : "1";
+                    returnedValue = innerChildElements.GetOrAdd($"{element.Name}-{methodOverloadNameSuffix}", element);
+                    added = true;
+                }
+
+            if(!added && returnedValue.GetType() != element.GetType())
+                throw new InvalidOperationException($"the current dom node already contains a child with name {returnedValue.Name} and of type {returnedValue.GetType().Name}");
+
+            return returnedValue;
+        }
+        public IEnumerable<T> FindChildrenByName<T>(string childName) where T: ICodeElement {
+            if(string.IsNullOrEmpty(childName))
+                throw new ArgumentNullException(nameof(childName));
+
+            if(InnerChildElements.Any()) {
+                var result = new List<T>();
+                var immediateResult = this.FindChildByName<T>(childName, false);
+                if(immediateResult != null)
+                    result.Add(immediateResult);
+                foreach(var childElement in InnerChildElements.Values.OfType<CodeBlock>())
+                    result.AddRange(childElement.FindChildrenByName<T>(childName));
+                return result;
+            } else
+                return Enumerable.Empty<T>();
+        }
+        public T FindChildByName<T>(string childName, bool findInChildElements = true) where T: ICodeElement {
+            if(string.IsNullOrEmpty(childName))
+                throw new ArgumentNullException(nameof(childName));
+            
+            if(!InnerChildElements.Any())
+                return default(T);
+
+            if(InnerChildElements.TryGetValue(childName, out var result) && result is T)
+                return (T)(object)result;
+            else if(findInChildElements)
+                foreach(var childElement in InnerChildElements.Values.OfType<CodeBlock>()) {
+                    var childResult = childElement.FindChildByName<T>(childName, true);
+                    if(childResult != null)
+                        return childResult;
+                }
+            return default(T);
         }
         public class BlockDeclaration : CodeTerminal
         {

src/Kiota.Builder/CodeDOM/CodeBlock.cs

@@ -13,7 +13,7 @@ public enum CodeClassKind {
     /// <summary>
     /// CodeClass represents an instance of a Class to be generated in source code
     /// </summary>
-    public class CodeClass : CodeBlock, IDocumentedElement
+    public class CodeClass : CodeBlock, IDocumentedElement, ITypeDefinition
     {
         private string name;
 
@@ -40,36 +40,33 @@ public override string Name
 
         public void SetIndexer(CodeIndexer indexer)
         {
-            this.InnerChildElements.Add(indexer);
+            AddRange(indexer);
         }
 
-        public void AddProperty(params CodeProperty[] properties)
+        public IEnumerable<CodeProperty> AddProperty(params CodeProperty[] properties)
         {
             if(!properties.Any() || properties.Any(x => x == null))
                 throw new ArgumentNullException(nameof(properties));
-            AddMissingParent(properties);
-            this.InnerChildElements.AddRange(properties);
+            return AddRange(properties);
         }
 
         public bool ContainsMember(string name)
         {
-            return this.InnerChildElements.Any(e => e.Name == name);
+            return this.InnerChildElements.ContainsKey(name);
         }
 
-        public void AddMethod(params CodeMethod[] methods)
+        public IEnumerable<CodeMethod> AddMethod(params CodeMethod[] methods)
         {
             if(!methods.Any() || methods.Any(x => x == null))
                 throw new ArgumentOutOfRangeException(nameof(methods));
-            AddMissingParent(methods);
-            this.InnerChildElements.AddRange(methods);
+            return AddRange(methods);
         }
 
-        public void AddInnerClass(params CodeClass[] codeClasses)
+        public IEnumerable<CodeClass> AddInnerClass(params CodeClass[] codeClasses)
         {
             if(!codeClasses.Any() || codeClasses.Any(x => x == null))
                 throw new ArgumentOutOfRangeException(nameof(codeClasses));
-            AddMissingParent(codeClasses);
-            this.InnerChildElements.AddRange(codeClasses);
+            return AddRange(codeClasses);
         }
         public CodeClass GetParentClass() {
             if(StartBlock is Declaration declaration)

src/Kiota.Builder/CodeDOM/CodeClass.cs

@@ -7,17 +7,17 @@ namespace Kiota.Builder
     /// <summary>
     /// Abstract element of some piece of source code to be generated
     /// </summary>
-    public abstract class CodeElement
+    public abstract class CodeElement : ICodeElement
     {
-        public Dictionary<string, object> GenerationProperties { get; set; } = new Dictionary<string, object>();
+        public Dictionary<string, object> GenerationProperties { get; set; } = new(StringComparer.OrdinalIgnoreCase);
         protected CodeElement(CodeElement parent)
         {
             if(parent == null && !(this is CodeNamespace))
                 throw new ArgumentNullException(nameof(parent));
             Parent = parent;
         }
         public CodeElement Parent { get; set; }
-        public abstract IList<CodeElement> GetChildElements();
+        public virtual IEnumerable<CodeElement> GetChildElements(bool innerOnly = false) => Enumerable.Empty<CodeElement>();
 
         public virtual string Name
         {