public void DegenerateQuery() { string program = @"using System; using System.Linq; class TestClass { void Test(string[] input) { $var$ r = from x in input select x; } } "; TypeResolveResult rr = Resolve <TypeResolveResult>(program); Assert.AreEqual("System.Collections.Generic.IEnumerable`1[[System.String]]", rr.Type.ReflectionName); }
public void InnerTypeResolve1() { string program = @"public class C<T> { public class Inner { } } class TestClass { void Test() { $C<string>.Inner$ a; } } "; TypeResolveResult trr = Resolve <TypeResolveResult>(program); Assert.AreEqual("C.Inner", trr.Type.FullName); }
public void ImportAliasTest() { string program = @"using COL = System.Collections; class TestClass { COL.ArrayList ff; } "; TypeResolveResult type = Resolve<TypeResolveResult>(program.Replace("COL.ArrayList", "$COL.ArrayList$")); Assert.IsNotNull(type, "COL.ArrayList should resolve to a type"); Assert.AreEqual("System.Collections.ArrayList", type.Type.FullName, "TypeResolveResult"); MemberResolveResult member = Resolve<MemberResolveResult>(program.Replace("ff", "$ff$")); Assert.AreEqual("System.Collections.ArrayList", member.Type.FullName, "the full type should be resolved"); }
public void AliasToImportedType2() { UsingScope mainUsingScope = new UsingScope(); mainUsingScope.Usings.Add(MakeReference("System")); UsingScope nestedUsingScope = new UsingScope(mainUsingScope, "SomeNamespace"); nestedUsingScope.UsingAliases.Add(new KeyValuePair <string, TypeOrNamespaceReference>("x", MakeReference("String"))); var resolverWithUsing = resolver.WithCurrentUsingScope(nestedUsingScope.Resolve(compilation)); TypeResolveResult trr = (TypeResolveResult)resolverWithUsing.ResolveSimpleName("x", new IType[0]); Assert.AreEqual("System.String", trr.Type.FullName); }
public void SD_1384() { string program = @"using System; class Flags { [Flags] enum $Test$ { } }"; TypeResolveResult result = Resolve <TypeResolveResult>(program); Assert.AreEqual("Flags.Test", result.Type.FullName); var rt = result.Type.GetDefinition().Attributes[0].AttributeType.Resolve(context); Assert.AreEqual("System.FlagsAttribute", rt.FullName); }
public void OrderingWithoutSelectCall() { string program = @"using System; using System.Linq; class TestClass { void Test(string[] input) { $var$ r = from x in input orderby x.Length select x; } } "; TypeResolveResult rr = Resolve <TypeResolveResult>(program); Assert.AreEqual("System.Linq.IOrderedEnumerable`1[[System.String]]", rr.Type.ReflectionName); }
public void ImportAliasClassResolveTest() { string program = @"using COL = System.Collections.ArrayList; class TestClass { void Test() { COL a = new COL(); } } "; TypeResolveResult trr = Resolve<AliasTypeResolveResult>(program.Replace("COL a", "$COL$ a")); Assert.AreEqual("System.Collections.ArrayList", trr.Type.FullName, "COL"); ResolveResult rr = Resolve<CSharpInvocationResolveResult>(program.Replace("new COL()", "$new COL()$")); Assert.AreEqual("System.Collections.ArrayList", rr.Type.FullName, "a"); }
public void ResolveTypeSD_863() { string program = @"using System; namespace A { class C {} } namespace A.B { class C {} class TestClass { void Test() { $C$ a; } } } "; TypeResolveResult trr = Resolve<TypeResolveResult>(program); Assert.AreEqual("A.B.C", trr.Type.FullName); }
public void OrderingWithSelectCallDueToSecondRangeVariable4() { string program = @"using System; using System.Linq; class TestClass { void Test(string[] input) { $var$ r = from x in input let y = x orderby x.Length select x; } } "; TypeResolveResult rr = Resolve <TypeResolveResult>(program); Assert.AreEqual("System.Collections.Generic.IEnumerable`1[[System.String]]", rr.Type.ReflectionName); }
public void ClassNameLookup3() { string program = @"namespace MainNamespace { using Test.Subnamespace; class Program { static void M($Test$ c) {} } } namespace Test { public class TheClass { } } namespace Test.Subnamespace { public class Test { public class TheClass { } } } "; TypeResolveResult trr = Resolve<TypeResolveResult>(program); Assert.AreEqual("Test.Subnamespace.Test", trr.Type.FullName); }
public void ResolveNamespaceSD_863() { string program = @"using System; namespace A.C { class D {} } namespace A.B.C { class D {} } namespace A.B { class TestClass { void Test() { C.D x; } } } "; NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program.Replace("C.D", "$C$.D")); Assert.AreEqual("A.B.C", nrr.NamespaceName, "nrr.Name"); TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("C.D", "$C.D$")); Assert.AreEqual("A.B.C.D", trr.Type.FullName); }
public void ClassWithSameNameAsNamespace() { string program = @"using System; namespace XX { class Test { static void X() { a = $; } } class XX { public static void Test() {} } }"; TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("$", "$XX$")); Assert.AreEqual("XX.XX", trr.Type.FullName); NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program.Replace("$", "$global::XX$.T")); Assert.AreEqual("XX", nrr.NamespaceName); trr = Resolve<TypeResolveResult>(program.Replace("$", "$global::XX.XX$")); Assert.AreEqual("XX.XX", trr.Type.FullName); InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$XX.Test()$")); Assert.AreEqual("XX.XX.Test", mrr.Member.FullName); }
public void PropertyNameAmbiguousWithTypeName() { string program = @"class A { public Color Color { get; set; } void Method() { $ } } class Color { public static readonly Color Empty = null; } "; TypeResolveResult trr = Resolve <TypeResolveResult>(program.Replace("$", "$Color$ c;")); Assert.AreEqual("Color", trr.Type.Name); MemberResolveResult mrr = Resolve <MemberResolveResult>(program.Replace("$", "x = $Color$;")); Assert.AreEqual("Color", mrr.Member.Name); Resolve <MemberResolveResult>(program.Replace("$", "$Color$ = Color.Empty;")); Resolve <TypeResolveResult>(program.Replace("$", "Color = $Color$.Empty;")); Resolve <MemberResolveResult>(program.Replace("$", "x = $Color$.ToString();")); }
public void Resolved(AstNode node, ResolveResult result) { if (ResolveVisitor.ActsAsParenthesizedExpression(node)) { return; } MemberResolveResult mrr = result as MemberResolveResult; if (mrr != null) { referenceFound(node, mrr.Member.MemberDefinition); } TypeResolveResult trr = result as TypeResolveResult; if (trr != null) { ITypeDefinition typeDef = trr.Type.GetDefinition(); if (typeDef != null) { referenceFound(node, typeDef); } } }
public void FindClassInCurrentNamespace() { var resolverWithUsing = resolver.WithCurrentUsingScope(MakeUsingScope("System.Collections")); TypeResolveResult trr = (TypeResolveResult)resolverWithUsing.ResolveSimpleName("String", new IType[0]); Assert.AreEqual("System.String", trr.Type.FullName); }
ResolveResult CreateResult(ResolveResult targetResolveResult, List <LookupGroup> lookupGroups, string name, IList <IType> typeArguments) { // Remove all hidden groups lookupGroups.RemoveAll(g => g.AllHidden); if (lookupGroups.Count == 0) { // No members found return(new UnknownMemberResolveResult(targetResolveResult.Type, name, typeArguments)); } if (lookupGroups.Any(g => !g.MethodsAreHidden && g.Methods.Count > 0)) { // If there are methods, make a MethodGroupResolveResult. // Note that a conflict between a member and a method (possible with multiple interface inheritance) // is only a warning, not an error, and the C# compiler will prefer the method group. List <MethodListWithDeclaringType> methodLists = new List <MethodListWithDeclaringType>(); foreach (var lookupGroup in lookupGroups) { if (!lookupGroup.MethodsAreHidden && lookupGroup.Methods.Count > 0) { var methodListWithDeclType = new MethodListWithDeclaringType(lookupGroup.DeclaringType); foreach (var method in lookupGroup.Methods) { methodListWithDeclType.Add((IMethod)method); } methodLists.Add(methodListWithDeclType); } } return(new MethodGroupResolveResult(targetResolveResult, name, methodLists, typeArguments)); } // If there are ambiguities, report the most-derived result (last group) LookupGroup resultGroup = lookupGroups[lookupGroups.Count - 1]; if (resultGroup.NestedTypes != null && resultGroup.NestedTypes.Count > 0) { if (resultGroup.NestedTypes.Count > 1 || !resultGroup.NonMethodIsHidden || lookupGroups.Count > 1) { return(new AmbiguousTypeResolveResult(resultGroup.NestedTypes[0])); } else { return(new TypeResolveResult(resultGroup.NestedTypes[0])); } } if (resultGroup.NonMethod.IsStatic && targetResolveResult is ThisResolveResult) { targetResolveResult = new TypeResolveResult(targetResolveResult.Type); } if (lookupGroups.Count > 1) { return(new AmbiguousMemberResolveResult(targetResolveResult, resultGroup.NonMethod)); } else { if (isInEnumMemberInitializer) { IField field = resultGroup.NonMethod as IField; if (field != null && field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum) { return(new MemberResolveResult( targetResolveResult, field, field.DeclaringTypeDefinition.EnumUnderlyingType, field.IsConst, field.ConstantValue)); } } return(new MemberResolveResult(targetResolveResult, resultGroup.NonMethod)); } }
public IType Resolve(ITypeResolveContext context) { TypeResolveResult rr = DoResolve(context) as TypeResolveResult; return(rr != null ? rr.Type : SharedTypes.UnknownType); }
public AliasTypeResolveResult(string alias, TypeResolveResult underlyingResult) : base(underlyingResult.Type) { this.Alias = alias; }
public void ImportedType() { var resolverWithUsing = resolver.WithCurrentUsingScope(MakeUsingScope(usings: new [] { "System" })); TypeResolveResult trr = (TypeResolveResult)resolverWithUsing.ResolveSimpleName("String", new IType[0]); Assert.AreEqual("System.String", trr.Type.FullName); }
internal override bool IsMatch(ResolveResult rr) { TypeResolveResult trr = rr as TypeResolveResult; return(trr != null && typeDefinition.Equals(trr.Type.GetDefinition())); }