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()));
}
