Prevent ambiguous type symbols in generated code [#59]

Author: Stephan

Zbu.ModelsBuilder.Tests/BuilderTests.cs

@@ -1697,6 +1697,7 @@ public void GenerateMixinType()
         public void WriteClrType(string expected, Type input)
         {
             var builder = new TextBuilder();
+            builder.ModelsNamespaceForTests = "ModelsNamespace";
             var sb = new StringBuilder();
             builder.WriteClrType(sb, input);
             Assert.AreEqual(expected, sb.ToString());
@@ -1710,13 +1711,78 @@ public void WriteClrTypeUsing(string expected, Type input)
         {
             var builder = new TextBuilder();
             builder.Using.Add("Zbu.ModelsBuilder.Tests");
+            builder.ModelsNamespaceForTests = "ModelsNamespace";
             var sb = new StringBuilder();
             builder.WriteClrType(sb, input);
             Assert.AreEqual(expected, sb.ToString());
         }
 
+        [Test]
+        public void WriteClrType_WithUsing()
+        {
+            var builder = new TextBuilder();
+            builder.Using.Add("System.Text");
+            builder.ModelsNamespaceForTests = "Zbu.ModelsBuilder.Tests.Models";
+            var sb = new StringBuilder();
+            builder.WriteClrType(sb, typeof(StringBuilder));
+            Assert.AreEqual("StringBuilder", sb.ToString());
+        }
+
+        [Test]
+        public void WriteClrTypeAnother_WithoutUsing()
+        {
+            var builder = new TextBuilder();
+            builder.ModelsNamespaceForTests = "Zbu.ModelsBuilder.Tests.Models";
+            var sb = new StringBuilder();
+            builder.WriteClrType(sb, typeof(StringBuilder));
+            Assert.AreEqual("System.Text.StringBuilder", sb.ToString());
+        }
+
+        [Test]
+        public void WriteClrType_Ambiguous()
+        {
+            var builder = new TextBuilder();
+            builder.Using.Add("System.Text");
+            builder.Using.Add("Zbu.ModelsBuilder.Tests");
+            builder.ModelsNamespaceForTests = "SomeRandomNamespace";
+            var sb = new StringBuilder();
+            builder.WriteClrType(sb, typeof(System.Text.ASCIIEncoding));
+            Assert.AreEqual("global::System.Text.ASCIIEncoding", sb.ToString());
+        }
+
+        [Test]
+        public void WriteClrType_AmbiguousNot()
+        {
+            var builder = new TextBuilder();
+            builder.Using.Add("System.Text");
+            builder.Using.Add("Zbu.ModelsBuilder.Tests");
+            builder.ModelsNamespaceForTests = "Zbu.ModelsBuilder.Tests.Models";
+            var sb = new StringBuilder();
+            builder.WriteClrType(sb, typeof(System.Text.ASCIIEncoding));
+            Assert.AreEqual("ASCIIEncoding", sb.ToString());
+        }
+
+        [Test]
+        public void WriteClrType_AmbiguousWithNested()
+        {
+            var builder = new TextBuilder();
+            builder.Using.Add("System.Text");
+            builder.Using.Add("Zbu.ModelsBuilder.Tests");
+            builder.ModelsNamespaceForTests = "SomeRandomNamespace";
+            var sb = new StringBuilder();
+            builder.WriteClrType(sb, typeof(ASCIIEncoding.Nested));
+            Assert.AreEqual("global::Zbu.ModelsBuilder.Tests.ASCIIEncoding.Nested", sb.ToString());
+        }
+
         public class Class1 { }
     }
 
+    // make it public to be ambiguous (see above)
+    public class ASCIIEncoding
+    {
+        // can we handle nested types?
+        public class Nested { }
+    }
+
     class BuilderTestsClass1 {}
 }

Zbu.ModelsBuilder.Tests/RoslynTests.cs

@@ -416,6 +416,150 @@ class MyClass
             Assert.AreEqual(0, diags.Length);
             // unknown attribute is a semantic error
         }
+
+        [Test]
+        public void SymbolLookup_Ambiguous1()
+        {
+            const string code = @"
+using System.Text;
+using Zbu.ModelsBuilder.Tests;
+namespace SomeCryptoNameThatDoesReallyNotExistEgAGuid
+{ }
+";
+
+            SemanticModel model;
+            int pos;
+            GetSemantic(code, out model, out pos);
+
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "StringBuilder"));
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "RoslynTests"));
+            Assert.AreEqual(2, LookupSymbol(model, pos, null, "ASCIIEncoding"));
+        }
+
+        public void SymbolLookup_Ambiguous2()
+        {
+            const string code = @"
+using System.Text;
+using Zbu.ModelsBuilder.Tests;
+namespace Zbu.ModelsBuilder.Tests.Models
+{ }
+";
+
+            SemanticModel model;
+            int pos;
+            GetSemantic(code, out model, out pos);
+
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "StringBuilder"));
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "RoslynTests"));
+
+            // not ambiguous !
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "ASCIIEncoding"));
+        }
+
+        [Test]
+        public void SymbolLookup()
+        {
+            const string code = @"
+using System.Collections.Generic;
+using System.Text;
+namespace MyNamespace
+{
+    // %%POS%%
+
+    public class MyClass
+    {
+        public MyClass()
+        { }
+
+        public void Do()
+        { }
+    }
+
+    public class OtherClass
+    {
+        public class NestedClass { }
+        private class HiddenClass { }
+    }
+}
+";
+            SemanticModel model;
+            int pos;
+            GetSemantic(code, out model, out pos);
+
+            // only in proper scope
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "MyClass"));
+            Assert.AreEqual(0, LookupSymbol(model, 0, null, "MyClass"));
+
+            // not! looking for symbols only
+            Assert.AreEqual(0, LookupSymbol(model, 0, null, "MyNamespace.MyClass"));
+            Assert.AreEqual(0, LookupSymbol(model, pos, null, "MyNamespace.MyClass"));
+
+            // yes!
+            Assert.AreEqual(1, LookupSymbol(model, 0, null, "StringBuilder"));
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "StringBuilder"));
+
+            // not! looking for symbols only
+            Assert.AreEqual(0, LookupSymbol(model, 0, null, "System.Text.StringBuilder"));
+            Assert.AreEqual(0, LookupSymbol(model, 0, null, "global::StringBuilder"));
+            Assert.AreEqual(0, LookupSymbol(model, 0, null, "global::System.Text.StringBuilder"));
+
+            // cannot find Int32 at root because of no using clause
+            Assert.AreEqual(0, LookupSymbol(model, 0, null, "Int32"));
+
+            // can find System.Collections.Generic.Dictionary<TKey, TValue> (using clause)
+            Assert.AreEqual(1, LookupSymbol(model, 0, null, "Dictionary"));
+
+            // can find OtherClass within MyNamespace, & nested...
+            Assert.AreEqual(1, LookupSymbol(model, pos, null, "OtherClass"));
+
+            // that's not how it works
+            //Assert.AreEqual(0, LookupSymbol(model, pos, null, "NestedClass"));
+            //Assert.AreEqual(1, LookupSymbol(model, pos, null, "OtherClass.NestedClass"));
+            //Assert.AreEqual(0, LookupSymbol(model, pos, null, "OtherClass+HiddenClass"));
+        }
+
+        private void GetSemantic(string code, out SemanticModel model, out int pos)
+        {
+            var tree = CSharpSyntaxTree.ParseText(code);
+
+            //var writer = new ConsoleDumpWalker();
+            //writer.Visit(tree.GetRoot());
+
+            var refs = AssemblyUtility.GetAllReferencedAssemblyLocations()
+                .Distinct()
+                .Select(x => MetadataReference.CreateFromFile(x));
+
+            var compilation = CSharpCompilation.Create(
+                "MyCompilation",
+                syntaxTrees: new[] { tree },
+                references: refs);
+            model = compilation.GetSemanticModel(tree);
+
+            var diags = model.GetDiagnostics();
+            foreach (var diag in diags)
+            {
+                if (diag.Id == "CS8019") continue;
+                Console.WriteLine(diag);
+                Assert.Fail();
+            }
+
+            var ns = tree.GetRoot().DescendantNodes().OfType<NamespaceDeclarationSyntax>().First();
+            pos = ns.OpenBraceToken.SpanStart;
+
+            // if we use that as a "container" then we get what's in the container *only*
+            // not what we want here, then we have to use the position to determine *scope*
+            //var ss = model.GetDeclaredSymbol(ns);
+        }
+
+        private int LookupSymbol(SemanticModel model, int pos, INamespaceOrTypeSymbol container, string symbol)
+        {
+            Console.WriteLine("lookup: " + symbol);
+            //var symbols = model.LookupSymbols(0, container, symbol);
+            var symbols = model.LookupNamespacesAndTypes(pos, container, symbol);
+            foreach (var x in symbols)
+                Console.WriteLine(x.ToDisplayString());
+            return symbols.Length;
+        }
     }
 
     class TestWalker : CSharpSyntaxWalker

Zbu.ModelsBuilder/Building/Builder.cs

@@ -1,6 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Zbu.ModelsBuilder.Building
 {
@@ -211,8 +215,52 @@ private void Prepare()
                 typeModel.HasCtor = true;
         }
 
+        private SemanticModel _ambiguousSymbolsModel;
+        private int _ambiguousSymbolsPos;
+
+        // internal for tests
+        internal void PrepareAmbiguousSymbols()
+        {
+            var codeBuilder = new StringBuilder();
+            foreach (var t in TypesUsing)
+                codeBuilder.AppendFormat("using {0};\n", t);
+
+            codeBuilder.AppendFormat("namespace {0}\n{{ }}\n", GetModelsNamespace());
+
+            var tree = CSharpSyntaxTree.ParseText(codeBuilder.ToString());
+
+            var refs = AssemblyUtility.GetAllReferencedAssemblyLocations()
+                .Distinct() // else massively duplicated...
+                .Select(x => MetadataReference.CreateFromFile(x));
+
+            var compilation = CSharpCompilation.Create(
+                "MyCompilation",
+                syntaxTrees: new[] { tree },
+                references: refs);
+            _ambiguousSymbolsModel = compilation.GetSemanticModel(tree);
+
+            var namespaceSyntax = tree.GetRoot().DescendantNodes().OfType<NamespaceDeclarationSyntax>().First();
+            //var namespaceSymbol = model.GetDeclaredSymbol(namespaceSyntax);
+            _ambiguousSymbolsPos = namespaceSyntax.OpenBraceToken.SpanStart;
+        }
+
+        protected bool IsAmbiguousSymbol(string symbol)
+        {
+            if (_ambiguousSymbolsModel == null)
+                PrepareAmbiguousSymbols();
+            if (_ambiguousSymbolsModel == null)
+                throw new Exception("Could not prepare ambiguous symbols.");
+            var symbols = _ambiguousSymbolsModel.LookupNamespacesAndTypes(_ambiguousSymbolsPos, null, symbol);
+            return symbols.Length > 1;
+        }
+
+        internal string ModelsNamespaceForTests;
+
         public string GetModelsNamespace()
         {
+            if (ModelsNamespaceForTests != null)
+                return ModelsNamespaceForTests;
+
             // code attribute overrides everything
             if (ParseResult.HasModelsNamespace)
                 return ParseResult.ModelsNamespace;

Zbu.ModelsBuilder/Building/TextBuilder.cs

@@ -343,20 +343,28 @@ internal void WriteClrType(StringBuilder sb, Type type)
 
         private void WriteNonGenericClrType(StringBuilder sb, string s)
         {
-            var ls = s.ToLowerInvariant();
-            if (TypesMap.ContainsKey(ls))
+            string typeName;
+            if (!TypesMap.TryGetValue(s.ToLowerInvariant(), out typeName)) // takes care eg of "System.Int32" vs. "int"
             {
-                s = TypesMap[ls];
-            }
-            else
-            {
-                var p = s.LastIndexOf('.');
-                if (p > 0 && TypesUsing.Contains(s.Substring(0, p)))
-                    s = s.Substring(p + 1);
-                s = s.Replace("+", "."); // nested types *after* using
+                // if full type name matches a using clause, strip
+                typeName = s;
+                var p = typeName.LastIndexOf('.');
+                if (p > 0 && TypesUsing.Contains(typeName.Substring(0, p)))
+                    typeName = typeName.Substring(p + 1);
+
+                // nested types *after* using
+                typeName = typeName.Replace("+", ".");
+
+                // symbol to test is the first part of the name
+                p = typeName.IndexOf('.');
+                var symbol = p > 0 ? typeName.Substring(0, p) : typeName;
+
+                // globalize anything that is ambiguous
+                if (IsAmbiguousSymbol(symbol))
+                    typeName = "global::" + s.Replace("+", ".");
             }
 
-            sb.Append(s);
+            sb.Append(typeName);
         }
 
         private static string XmlCommentString(string s)