Exemple #1
0
        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;
		}
Exemple #3
0
 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;
 }
Exemple #4
0
        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);
        }
Exemple #8
0
        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);
            }
        }
Exemple #9
0
        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;
        }
Exemple #10
0
		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;
		}
Exemple #11
0
            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);
                }
            }
Exemple #12
0
 public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode)
 {
     return(SpecialType.UnknownType);
 }
Exemple #13
0
		public static ITypeReference ConvertType(AstType type, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
		{
			return type.ToTypeReference(lookupMode);
		}
Exemple #14
0
 /// <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);
Exemple #15
0
 public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode)
 {
     throw new NotSupportedException();
 }