public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { TypeOrNamespaceReference t; if (this.IsDoubleColon) { SimpleType st = this.Target as SimpleType; if (st != null) { t = new AliasNamespaceReference(st.Identifier); } else { t = null; } } else { t = this.Target.ToTypeReference(lookupMode) as TypeOrNamespaceReference; } if (t == null) { return(SpecialType.UnknownType); } var typeArguments = new List <ITypeReference>(); foreach (var ta in this.TypeArguments) { typeArguments.Add(ta.ToTypeReference(lookupMode)); } return(new MemberTypeOrNamespaceReference(t, this.MemberName, typeArguments)); }
public SimpleTypeOrNamespaceReference(string identifier, IList<ITypeReference> typeArguments, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { if (identifier == null) throw new ArgumentNullException("identifier"); this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList<ITypeReference>.Instance; this.lookupMode = lookupMode; }
public SimpleTypeOrNamespaceReference(string identifier, IList <ITypeReference> typeArguments, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { if (identifier == null) { throw new ArgumentNullException("identifier"); } this.identifier = identifier; this.typeArguments = typeArguments ?? EmptyList <ITypeReference> .Instance; this.lookupMode = lookupMode; }
public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { KnownTypeCode typeCode = GetTypeCodeForPrimitiveType(this.Keyword); if (typeCode == KnownTypeCode.None) { return(new UnknownType(null, this.Keyword)); } else { return(KnownTypeReference.Get(typeCode)); } }
public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { var typeArguments = new List <ITypeReference>(); foreach (var ta in this.TypeArguments) { typeArguments.Add(ta.ToTypeReference(lookupMode)); } if (typeArguments.Count == 0 && string.IsNullOrEmpty(this.Identifier)) { // empty SimpleType is used for typeof(List<>). return(SpecialType.UnboundTypeArgument); } return(new SimpleTypeOrNamespaceReference(this.Identifier, typeArguments, lookupMode)); }
void HandleMemberReference(AstNode wholeNode, AstNode targetNode, Identifier memberName, IEnumerable<AstType> typeArguments, SimpleNameLookupMode mode, Action<Script> action) { var result = ctx.Resolve(targetNode); if (!(result is NamespaceResolveResult)) { return; } var wholeResult = ctx.Resolve(wholeNode); if (!(wholeResult is TypeResolveResult)) { return; } var state = ctx.GetResolverStateBefore(wholeNode); var resolvedTypeArguments = typeArguments.Select(ctx.ResolveType).ToList(); var lookupName = state.LookupSimpleNameOrTypeName(memberName.Name, resolvedTypeArguments, mode); if (lookupName is TypeResolveResult && !lookupName.IsError && wholeResult.Type.Equals(lookupName.Type)) { AddIssue(wholeNode.StartLocation, memberName.StartLocation, ctx.TranslateString("Remove redundant namespace usage"), action); } }
public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { ITypeReference t = this.BaseType.ToTypeReference(lookupMode); if (this.HasNullableSpecifier) { t = NullableType.Create(t); } int pointerRank = this.PointerRank; for (int i = 0; i < pointerRank; i++) { t = new PointerTypeReference(t); } foreach (var a in this.ArraySpecifiers.Reverse()) { t = new ArrayTypeReference(t, a.Dimensions); } return(t); }
public ResolveResult LookupSimpleNameOrTypeName(string identifier, IList<IType> typeArguments, SimpleNameLookupMode lookupMode) { // C# 4.0 spec: §3.8 Namespace and type names; §7.6.2 Simple Names if (identifier == null) throw new ArgumentNullException("identifier"); if (typeArguments == null) throw new ArgumentNullException("typeArguments"); int k = typeArguments.Count; if (k == 0) { if (lookupMode == SimpleNameLookupMode.Expression || lookupMode == SimpleNameLookupMode.InvocationTarget) { // Look in local variables foreach (IVariable v in this.LocalVariables) { if (v.Name == identifier) { return new LocalResolveResult(v); } } // Look in parameters of current method IParameterizedMember parameterizedMember = this.CurrentMember as IParameterizedMember; if (parameterizedMember != null) { foreach (IParameter p in parameterizedMember.Parameters) { if (p.Name == identifier) { return new LocalResolveResult(p); } } } } // look in type parameters of current method IMethod m = this.CurrentMember as IMethod; if (m != null) { foreach (ITypeParameter tp in m.TypeParameters) { if (tp.Name == identifier) return new TypeResolveResult(tp); } } } bool parameterizeResultType = !(typeArguments.Count != 0 && typeArguments.All(t => t.Kind == TypeKind.UnboundTypeArgument)); ResolveResult r = null; if (currentTypeDefinitionCache != null) { Dictionary<string, ResolveResult> cache = null; bool foundInCache = false; if (k == 0) { switch (lookupMode) { case SimpleNameLookupMode.Expression: cache = currentTypeDefinitionCache.SimpleNameLookupCacheExpression; break; case SimpleNameLookupMode.InvocationTarget: cache = currentTypeDefinitionCache.SimpleNameLookupCacheInvocationTarget; break; case SimpleNameLookupMode.Type: cache = currentTypeDefinitionCache.SimpleTypeLookupCache; break; } if (cache != null) { foundInCache = cache.TryGetValue(identifier, out r); } } if (!foundInCache) { r = LookInCurrentType(identifier, typeArguments, lookupMode, parameterizeResultType); if (cache != null) { // also cache missing members (r==null) cache[identifier] = r; } } if (r != null) return r; } if (context.CurrentUsingScope != null) { if (k == 0 && lookupMode != SimpleNameLookupMode.TypeInUsingDeclaration) { if (!context.CurrentUsingScope.ResolveCache.TryGetValue(identifier, out r)) { r = LookInCurrentUsingScope(identifier, typeArguments, false, false); r = context.CurrentUsingScope.ResolveCache.GetOrAdd(identifier, r); } } else { r = LookInCurrentUsingScope(identifier, typeArguments, lookupMode == SimpleNameLookupMode.TypeInUsingDeclaration, parameterizeResultType); } if (r != null) return r; } if (typeArguments.Count == 0 && identifier == "dynamic") { return new TypeResolveResult(SpecialType.Dynamic); } else { return new UnknownIdentifierResolveResult(identifier, typeArguments.Count); } }
ResolveResult LookInCurrentType(string identifier, IList<IType> typeArguments, SimpleNameLookupMode lookupMode, bool parameterizeResultType) { int k = typeArguments.Count; MemberLookup lookup = CreateMemberLookup(); // look in current type definitions for (ITypeDefinition t = this.CurrentTypeDefinition; t != null; t = t.DeclaringTypeDefinition) { if (k == 0) { // look for type parameter with that name var typeParameters = t.TypeParameters; // only look at type parameters defined directly on this type, not at those copied from outer classes for (int i = (t.DeclaringTypeDefinition != null ? t.DeclaringTypeDefinition.TypeParameterCount : 0); i < typeParameters.Count; i++) { if (typeParameters[i].Name == identifier) return new TypeResolveResult(typeParameters[i]); } } if (lookupMode == SimpleNameLookupMode.BaseTypeReference && t == this.CurrentTypeDefinition) { // don't look in current type when resolving a base type reference continue; } ResolveResult r; if (lookupMode == SimpleNameLookupMode.Expression || lookupMode == SimpleNameLookupMode.InvocationTarget) { r = lookup.Lookup(new TypeResolveResult(t), identifier, typeArguments, lookupMode == SimpleNameLookupMode.InvocationTarget); } else { r = lookup.LookupType(t, identifier, typeArguments, parameterizeResultType); } if (!(r is UnknownMemberResolveResult)) // but do return AmbiguousMemberResolveResult return r; } return null; }
ResolveResult LookInCurrentType(string identifier, IList<IType> typeArguments, SimpleNameLookupMode lookupMode, bool parameterizeResultType) { int k = typeArguments.Count; MemberLookup lookup; if (lookupMode == SimpleNameLookupMode.BaseTypeReference && this.CurrentTypeDefinition != null) { // When looking up a base type reference, treat us as being outside the current type definition // for accessibility purposes. // This avoids a stack overflow when referencing a protected class nested inside the base class // of a parent class. (NameLookupTests.InnerClassInheritingFromProtectedBaseInnerClassShouldNotCauseStackOverflow) lookup = new MemberLookup(this.CurrentTypeDefinition.DeclaringTypeDefinition, this.Compilation.MainAssembly, false); } else { lookup = CreateMemberLookup(); } // look in current type definitions for (ITypeDefinition t = this.CurrentTypeDefinition; t != null; t = t.DeclaringTypeDefinition) { if (k == 0) { // Look for type parameter with that name var typeParameters = t.TypeParameters; // Look at all type parameters, including those copied from outer classes, // so that we can fetch the version with the correct owner. for (int i = 0; i < typeParameters.Count; i++) { if (typeParameters[i].Name == identifier) return new TypeResolveResult(typeParameters[i]); } } if (lookupMode == SimpleNameLookupMode.BaseTypeReference && t == this.CurrentTypeDefinition) { // don't look in current type when resolving a base type reference continue; } ResolveResult r; if (lookupMode == SimpleNameLookupMode.Expression || lookupMode == SimpleNameLookupMode.InvocationTarget) { var targetResolveResult = (t == this.CurrentTypeDefinition ? ResolveThisReference() : new TypeResolveResult(t)); r = lookup.Lookup(targetResolveResult, identifier, typeArguments, lookupMode == SimpleNameLookupMode.InvocationTarget); } else { r = lookup.LookupType(t, identifier, typeArguments, parameterizeResultType); } if (!(r is UnknownMemberResolveResult)) // but do return AmbiguousMemberResolveResult return r; } return null; }
void HandleMemberReference(AstNode wholeNode, AstNode targetNode, Identifier memberName, IEnumerable <AstType> typeArguments, SimpleNameLookupMode mode, Action <Script> action) { var result = ctx.Resolve(targetNode); if (!(result is NamespaceResolveResult)) { return; } var wholeResult = ctx.Resolve(wholeNode); if (!(wholeResult is TypeResolveResult)) { return; } var state = ctx.GetResolverStateBefore(wholeNode); var resolvedTypeArguments = typeArguments.Select(ctx.ResolveType).ToList(); var lookupName = state.LookupSimpleNameOrTypeName(memberName.Name, resolvedTypeArguments, mode); if (lookupName is TypeResolveResult && !lookupName.IsError && wholeResult.Type.Equals(lookupName.Type)) { AddIssue(wholeNode.StartLocation, memberName.StartLocation, ctx.TranslateString("Remove redundant namespace usage"), action); } }
public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode) { return(SpecialType.UnknownType); }
public static ITypeReference ConvertType(AstType type, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type) { return type.ToTypeReference(lookupMode); }
/// <summary> /// Create an ITypeReference for this AstType. /// </summary> /// <remarks> /// The resulting type reference will read the context information from the /// <see cref="ITypeResolveContext"/>: /// For resolving type parameters, the CurrentTypeDefinition/CurrentMember is used. /// For resolving simple names, the current namespace and usings from the CurrentUsingScope /// (on CSharpTypeResolveContext only) is used. /// </remarks> public abstract ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type);
public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode) { throw new NotSupportedException(); }