public BVE5Compilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences) { if(solutionSnapshot == null) throw new ArgumentNullException("solutionSnapshot"); if(mainAssembly == null) throw new ArgumentNullException("mainAssembly"); if(assemblyReferences == null) throw new ArgumentNullException("assemblyReferences"); solution_snapshot = solutionSnapshot; context = new SimpleTypeResolveContext(this); main_assembly = mainAssembly.Resolve(context); var assemblies = new List<IAssembly>{main_assembly}; var referenced_assemblies = new List<IAssembly>(); foreach(var asm_ref in assemblyReferences){ IAssembly asm = asm_ref.Resolve(context); if(asm != null && !assemblies.Contains(asm)) assemblies.Add(asm); if(asm != null && !referenced_assemblies.Contains(asm)) referenced_assemblies.Add(asm); } this.assemblies = assemblies.AsReadOnly(); this.referenced_assemblies = referenced_assemblies.AsReadOnly(); this.type_cache = new PrimitiveTypeCache(this); }
public TypeInference(ITypeResolveContext context, Conversions conversions = null) { if (context == null) throw new ArgumentNullException("context"); this.context = context; this.conversions = conversions ?? Conversions.Get(context); }
public CecilResolvedAttribute(ITypeResolveContext context, UnresolvedAttributeBlob unresolved) { this.context = context; this.blob = unresolved.blob; this.ctorParameterTypes = unresolved.ctorParameterTypes; this.attributeType = unresolved.attributeType.Resolve(context); }
/// <summary> /// Gets the non-interface base types. /// </summary> /// <remarks> /// When <paramref name="type"/> is an interface, this method will also return base interfaces. /// /// The output is ordered so that base types occur in before derived types. /// </remarks> public static IEnumerable<IType> GetNonInterfaceBaseTypes(this IType type, ITypeResolveContext context) { BaseTypeCollector collector = new BaseTypeCollector(context); collector.SkipImplementedInterfaces = true; collector.CollectBaseTypes(type); return collector; }
public IAssembly Resolve(ITypeResolveContext context) { var project = _solution.Projects.FirstOrDefault(p => string.Equals(p.Title, _projectTitle, StringComparison.OrdinalIgnoreCase)); if (project != null) return project.ProjectContent.Resolve(context); return null; }
public IAssembly Resolve(ITypeResolveContext context) { IAssembly asm = context.CurrentAssembly; if (asm == null) throw new ArgumentException("A reference to the current assembly cannot be resolved in the compilation's global type resolve context."); return asm; }
/// <summary> /// Creates a new TypeSystemAstBuilder. /// </summary> /// <param name="context"> /// Context used for resolving types. /// </param> public TypeSystemAstBuilder(ITypeResolveContext context) { if (context == null) throw new ArgumentNullException("context"); this.context = context; InitProperties(); }
ISymbol ISymbolReference.Resolve(ITypeResolveContext context) { var type = Resolve(context); if (type is ITypeDefinition) return (ISymbol)type; return null; }
public IMethod ResolveConstructor(ITypeResolveContext context) { IType[] parameterTypes = null; if (constructorParameterTypes != null && constructorParameterTypes.Length > 0) { parameterTypes = new IType[constructorParameterTypes.Length]; for (int i = 0; i < parameterTypes.Length; i++) { parameterTypes[i] = constructorParameterTypes[i].Resolve(context); } } IMethod bestMatch = null; foreach (IMethod ctor in attributeType.Resolve(context).GetConstructors(context)) { if (ctor.IsStatic) continue; if (parameterTypes == null) { if (ctor.Parameters.Count == 0) return ctor; } else if (ctor.Parameters.Count == parameterTypes.Length) { bestMatch = ctor; bool ok = true; for (int i = 0; i < parameterTypes.Length; i++) { if (ctor.Parameters[i].Type != parameterTypes[i]) { ok = false; break; } } if (ok) return ctor; } } return bestMatch; }
public IMember Resolve(ITypeResolveContext context) { IType type = typeReference.Resolve(context); IEnumerable<IMember> members; if (entityType == EntityType.Method) { members = type.GetMethods( m => m.Name == name && m.EntityType == EntityType.Method && m.TypeParameters.Count == typeParameterCount, GetMemberOptions.IgnoreInheritedMembers); } else { members = type.GetMembers( m => m.Name == name && m.EntityType == entityType, GetMemberOptions.IgnoreInheritedMembers); } var resolvedParameterTypes = parameterTypes.Resolve(context); foreach (IMember member in members) { IParameterizedMember parameterizedMember = member as IParameterizedMember; if (parameterTypes.Count == 0) { if (parameterizedMember == null || parameterizedMember.Parameters.Count == 0) return member; } else if (parameterTypes.Count == parameterizedMember.Parameters.Count) { bool signatureMatches = true; for (int i = 0; i < parameterTypes.Count; i++) { IType type1 = ParameterListComparer.Instance.NormalizeMethodTypeParameters(resolvedParameterTypes[i]); IType type2 = ParameterListComparer.Instance.NormalizeMethodTypeParameters(parameterizedMember.Parameters[i].Type); if (!type1.Equals(type2)) { signatureMatches = false; break; } } if (signatureMatches) return member; } } return null; }
IType ITypeReference.Resolve(ITypeResolveContext context) { // Strictly speaking, we might have to resolve the type in a nested compilation, similar // to what we're doing with ConstantExpression. // However, in almost all cases this will work correctly - if the resulting type is only available in the // nested compilation and not in this, we wouldn't be able to map it anyways. var ctx = context as CSharpTypeResolveContext; if (ctx == null) { ctx = new CSharpTypeResolveContext(context.CurrentAssembly ?? context.Compilation.MainAssembly, null, context.CurrentTypeDefinition, context.CurrentMember); } return ResolveType(new CSharpResolver(ctx)); // A potential issue might be this scenario: // Assembly 1: // class A { public class Nested {} } // Assembly 2: (references asm 1) // class B : A {} // Assembly 3: (references asm 1 and 2) // class C { public B.Nested Field; } // Assembly 4: (references asm 1 and 3, but not 2): // uses C.Field; // Here we would not be able to resolve 'B.Nested' in the compilation of assembly 4, as type B is missing there. }
/* sealed class CachedResult { public readonly CacheManager CacheManager; public readonly IType Result; public CachedResult(CacheManager cacheManager, IType result) { this.CacheManager = cacheManager; this.Result = result; } } */ public IType Resolve(ITypeResolveContext context) { if (context == null) throw new ArgumentNullException("context"); /* TODO PERF: caching disabled until we measure how much of an advantage it is * (and whether other approaches like caching only the last N resolve calls in a thread-static cache would work better) * Maybe even make a distinction between the really common type references (e.g. primitiveTypeReferences) and * normal GetClassTypeReferences? CacheManager cacheManager = context.CacheManager; if (cacheManager != null) { CachedResult result = this.v_cachedResult; if (result != null && result.CacheManager == cacheManager) return result.Result; IType newResult = DoResolve(context); this.v_cachedResult = new CachedResult(cacheManager, newResult); cacheManager.Disposed += delegate { v_cachedResult = null; }; // maybe optimize this to use interface call instead of delegate? return newResult; } else { return DoResolve(context); } } IType DoResolve(ITypeResolveContext context) { */ return context.GetClass(nameSpace, name, typeParameterCount, StringComparer.Ordinal) ?? SharedTypes.UnknownType; }
public bool? IsReferenceType(ITypeResolveContext context) { switch (flags.Data & (FlagReferenceTypeConstraint | FlagValueTypeConstraint)) { case FlagReferenceTypeConstraint: return true; case FlagValueTypeConstraint: return false; } // protect against cyclic dependencies between type parameters using (var busyLock = BusyManager.Enter(this)) { if (busyLock.Success) { foreach (ITypeReference constraintRef in this.Constraints) { IType constraint = constraintRef.Resolve(context); ITypeDefinition constraintDef = constraint.GetDefinition(); // While interfaces are reference types, an interface constraint does not // force the type parameter to be a reference type; so we need to explicitly look for classes here. if (constraintDef != null && constraintDef.ClassType == ClassType.Class) return true; if (constraint is ITypeParameter) { bool? isReferenceType = constraint.IsReferenceType(context); if (isReferenceType.HasValue) return isReferenceType.Value; } } } } return null; }
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences) { if (solutionSnapshot == null) throw new ArgumentNullException("solutionSnapshot"); if (mainAssembly == null) throw new ArgumentNullException("mainAssembly"); if (assemblyReferences == null) throw new ArgumentNullException("assemblyReferences"); this.solutionSnapshot = solutionSnapshot; this.context = new SimpleTypeResolveContext(this); this.mainAssembly = mainAssembly.Resolve(context); List<IAssembly> assemblies = new List<IAssembly>(); assemblies.Add(this.mainAssembly); List<IAssembly> referencedAssemblies = new List<IAssembly>(); foreach (var asmRef in assemblyReferences) { IAssembly asm = asmRef.Resolve(context); if (asm != null && !assemblies.Contains(asm)) assemblies.Add(asm); if (asm != null && !referencedAssemblies.Contains(asm)) referencedAssemblies.Add(asm); } this.assemblies = assemblies.AsReadOnly(); this.referencedAssemblies = referencedAssemblies.AsReadOnly(); this.knownTypeCache = new KnownTypeCache(this); }
/// <summary> /// Gets all base types. /// </summary> /// <remarks>This is the reflexive and transitive closure of <see cref="IType.GetBaseTypes"/>. /// Note that this method does not return all supertypes - doing so is impossible due to contravariance /// (and undesirable for covariance as the list could become very large). /// </remarks> public static IEnumerable<IType> GetAllBaseTypes(this IType type, ITypeResolveContext context) { List<IType> output = new List<IType>(); Stack<ITypeDefinition> activeTypeDefinitions = new Stack<ITypeDefinition>(); CollectAllBaseTypes(type, context, activeTypeDefinitions, output); return output; }
public IList<KeyValuePair<string, IConstantValue>> GetNamedArguments(ITypeResolveContext context) { if (namedArguments != null) return new ReadOnlyCollection<KeyValuePair<string, IConstantValue>>(namedArguments); else return EmptyList<KeyValuePair<string, IConstantValue>>.Instance; }
public IMethod ResolveConstructor(ITypeResolveContext context) { CSharpResolver r = new CSharpResolver(context); IType type = attributeType.Resolve(context); int totalArgumentCount = 0; if (positionalArguments != null) totalArgumentCount += positionalArguments.Count; if (namedCtorArguments != null) totalArgumentCount += namedCtorArguments.Count; ResolveResult[] arguments = new ResolveResult[totalArgumentCount]; string[] argumentNames = new string[totalArgumentCount]; int i = 0; if (positionalArguments != null) { while (i < positionalArguments.Count) { IConstantValue cv = positionalArguments[i]; arguments[i] = cv.Resolve(context); i++; } } if (namedCtorArguments != null) { foreach (var pair in namedCtorArguments) { argumentNames[i] = pair.Key; arguments[i] = pair.Value.Resolve(context); i++; } } MemberResolveResult mrr = r.ResolveObjectCreation(type, arguments, argumentNames) as MemberResolveResult; return mrr != null ? mrr.Member as IMethod : null; }
public IList<IConstantValue> GetPositionalArguments(ITypeResolveContext context) { if (namedCtorArguments == null || namedCtorArguments.Count == 0) { // no namedCtorArguments: just return the positionalArguments if (positionalArguments != null) return new ReadOnlyCollection<IConstantValue>(positionalArguments); else return EmptyList<IConstantValue>.Instance; } // we do have namedCtorArguments, which need to be re-ordered and appended to the positional arguments List<IConstantValue> result = new List<IConstantValue>(this.positionalArguments); IMethod method = ResolveConstructor(context); if (method != null) { for (int i = result.Count; i < method.Parameters.Count; i++) { IParameter p = method.Parameters[i]; bool found = false; foreach (var pair in namedCtorArguments) { if (pair.Key == p.Name) { result.Add(pair.Value); found = true; } } if (!found) { // add the parameter's default value: result.Add(p.DefaultValue ?? new SimpleConstantValue(p.Type, CSharpResolver.GetDefaultValue(p.Type.Resolve(context)))); } } } return result.AsReadOnly(); }
public IAssembly Resolve(ITypeResolveContext context) { var project = _solution.Projects.FirstOrDefault(p => p.ProjectId == _projectGuid); if (project != null) return project.ProjectContent.Resolve(context); return null; }
public object GetValue(ITypeResolveContext context) { if (value is ITypeReference) return ((ITypeReference)value).Resolve(context); else return value; }
public IType Resolve(ITypeResolveContext context) { string[] parts = typeName.Split('.'); var assemblies = new [] { context.CurrentAssembly }.Concat(context.Compilation.Assemblies); for (int i = parts.Length - 1; i >= 0; i--) { string ns = string.Join(".", parts, 0, i); string name = parts[i]; int topLevelTPC = (i == parts.Length - 1 ? typeParameterCount : 0); foreach (var asm in assemblies) { if (asm == null) continue; ITypeDefinition typeDef = asm.GetTypeDefinition(new TopLevelTypeName(ns, name, topLevelTPC)); for (int j = i + 1; j < parts.Length && typeDef != null; j++) { int tpc = (j == parts.Length - 1 ? typeParameterCount : 0); typeDef = typeDef.NestedTypes.FirstOrDefault(n => n.Name == parts[j] && n.TypeParameterCount == tpc); } if (typeDef != null) return typeDef; } } int idx = typeName.LastIndexOf('.'); if (idx < 0) return new UnknownType("", typeName, typeParameterCount); // give back a guessed namespace/type name return new UnknownType(typeName.Substring(0, idx), typeName.Substring(idx + 1), typeParameterCount); }
public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable<IAssemblyReference> assemblyReferences) { if (solutionSnapshot == null) throw new ArgumentNullException("solutionSnapshot"); if (mainAssembly == null) throw new ArgumentNullException("mainAssembly"); if (assemblyReferences == null) throw new ArgumentNullException("assemblyReferences"); this.solutionSnapshot = solutionSnapshot; this.context = new SimpleTypeResolveContext(this); this.mainAssembly = mainAssembly.Resolve(context); List<IAssembly> assemblies = new List<IAssembly>(); assemblies.Add(this.mainAssembly); List<IAssembly> referencedAssemblies = new List<IAssembly>(); foreach (var asmRef in assemblyReferences) { IAssembly asm; try { asm = asmRef.Resolve(context); } catch (InvalidOperationException) { throw new InvalidOperationException("Tried to initialize compilation with an invalid assembly reference. (Forgot to load the assembly reference ? - see CecilLoader)"); } if (asm != null && !assemblies.Contains(asm)) assemblies.Add(asm); if (asm != null && !referencedAssemblies.Contains(asm)) referencedAssemblies.Add(asm); } this.assemblies = assemblies.AsReadOnly(); this.referencedAssemblies = referencedAssemblies.AsReadOnly(); this.knownTypeCache = new KnownTypeCache(this); }
public MemberLookup(ITypeResolveContext context, ITypeDefinition currentTypeDefinition, IProjectContent currentProject) { if (context == null) throw new ArgumentNullException("context"); this.context = context; this.currentTypeDefinition = currentTypeDefinition; this.currentProject = currentProject; }
/// <summary> /// Creates a new TypeSystemAstBuilder. /// </summary> /// <param name="resolver"> /// A resolver initialized for the position where the type will be inserted. /// </param> public TypeSystemAstBuilder(CSharpResolver resolver) { if (resolver == null) throw new ArgumentNullException("resolver"); this.resolver = resolver; this.context = resolver.Context; InitProperties(); }
/// <summary> /// Creates a <see cref="CompositeTypeResolveContext"/> that combines the given resolve contexts. /// If one of the input parameters is null, the other input parameter is returned directly. /// If both input parameters are null, the function returns null. /// </summary> public static ITypeResolveContext Combine(ITypeResolveContext a, ITypeResolveContext b) { if (a == null) return b; if (b == null) return a; return new CompositeTypeResolveContext(new [] { a, b }); }
public IAssembly Resolve(ITypeResolveContext context) { var project = _solution.Projects.FirstOrDefault(p => p.ProjectId == _projectGuid); if (project != null) return project.ProjectContent.Resolve(context); Console.WriteLine("Could not find project " + _projectTitle); return null; }
public ResolveResult Resolve(ITypeResolveContext context) { if (value is ITypeReference) { return new TypeOfResolveResult(type.Resolve(context), ((ITypeReference)value).Resolve(context)); } else { return new ConstantResolveResult(type.Resolve(context), value); } }
public override ITypeParameter CreateResolvedTypeParameter(ITypeResolveContext context) { if (context.CurrentMember is IMethod) { return new ResolvedMethodTypeParameterWithInheritedConstraints(this, context); } else { return base.CreateResolvedTypeParameter(context); } }
public IMember Resolve(ITypeResolveContext context) { IMethod method = accessorReference.Resolve(context) as IMethod; if (method != null) return method.AccessorOwner; else return null; }
public DefaultResolvedMethod(IUnresolvedMethod unresolved, ITypeResolveContext parentContext, bool isExtensionMethod) : base(unresolved, parentContext) { this.Parameters = unresolved.Parameters.CreateResolvedParameters(context); this.ReturnTypeAttributes = unresolved.ReturnTypeAttributes.CreateResolvedAttributes(parentContext); this.TypeParameters = unresolved.TypeParameters.CreateResolvedTypeParameters(context); this.IsExtensionMethod = isExtensionMethod; }
public override IMember CreateResolved(ITypeResolveContext context) { return(new ResolvedPropertySpec(this, context)); }
public static IMember Resolve(ITypeResolveContext context, SymbolKind symbolKind, string name, ITypeReference explicitInterfaceTypeReference = null, IList <string> typeParameterNames = null, IList <ITypeReference> parameterTypeReferences = null) { if (context.CurrentTypeDefinition == null) { return(null); } if (parameterTypeReferences == null) { parameterTypeReferences = EmptyList <ITypeReference> .Instance; } if (typeParameterNames == null || typeParameterNames.Count == 0) { // non-generic member // In this case, we can simply resolve the parameter types in the given context var parameterTypes = parameterTypeReferences.Resolve(context); if (explicitInterfaceTypeReference == null) { foreach (IMember member in context.CurrentTypeDefinition.Members) { if (member.IsExplicitInterfaceImplementation) { continue; } if (IsNonGenericMatch(member, symbolKind, name, parameterTypes)) { return(member); } } } else { IType explicitInterfaceType = explicitInterfaceTypeReference.Resolve(context); foreach (IMember member in context.CurrentTypeDefinition.Members) { if (!member.IsExplicitInterfaceImplementation) { continue; } if (member.ImplementedInterfaceMembers.Count != 1) { continue; } if (IsNonGenericMatch(member, symbolKind, name, parameterTypes)) { if (explicitInterfaceType.Equals(member.ImplementedInterfaceMembers[0].DeclaringType)) { return(member); } } } } } else { // generic member // In this case, we must specify the correct context for resolving the parameter types foreach (IMethod method in context.CurrentTypeDefinition.Methods) { if (method.SymbolKind != symbolKind) { continue; } if (method.Name != name) { continue; } if (method.Parameters.Count != parameterTypeReferences.Count) { continue; } // Compare type parameter count and names: if (!typeParameterNames.SequenceEqual(method.TypeParameters.Select(tp => tp.Name))) { continue; } // Once we know the type parameter names are fitting, we can resolve the // type references in the context of the method: var contextForMethod = context.WithCurrentMember(method); var parameterTypes = parameterTypeReferences.Resolve(contextForMethod); if (!IsParameterTypeMatch(method, parameterTypes)) { continue; } if (explicitInterfaceTypeReference == null) { if (!method.IsExplicitInterfaceImplementation) { return(method); } } else if (method.IsExplicitInterfaceImplementation && method.ImplementedInterfaceMembers.Count == 1) { IType explicitInterfaceType = explicitInterfaceTypeReference.Resolve(contextForMethod); if (explicitInterfaceType.Equals(method.ImplementedInterfaceMembers[0].DeclaringType)) { return(method); } } } } return(null); }
internal SpecializedParameterizedMember(IType declaringType, IParameterizedMember memberDefinition, TypeVisitor substitution, ITypeResolveContext context) : base(declaringType, memberDefinition, substitution, context) { var paramDefs = memberDefinition.Parameters; if (paramDefs.Count == 0) { this.parameters = EmptyList <IParameter> .Instance; } else { var parameters = new IParameter[paramDefs.Count]; for (int i = 0; i < parameters.Length; i++) { ITypeReference newType = Substitute(paramDefs[i].Type, substitution, context); if (newType != paramDefs[i].Type) { parameters[i] = new DefaultParameter(paramDefs[i]) { Type = newType }; } else { parameters[i] = paramDefs[i]; } } this.parameters = Array.AsReadOnly(parameters); } }
public ISymbol Resolve(ITypeResolveContext context) { return(new DefaultParameter(type.Resolve(context), name, region: region, isRef: isRef, isOut: isOut, isParams: isParams, isOptional: isOptional, defaultValue: defaultValue)); }
IType IConstantValue.GetValueType(ITypeResolveContext context) { Contract.Requires(context != null); Contract.Ensures(Contract.Result <IType>() != null); return(null); }
IEvent IUnresolvedEvent.Resolve(ITypeResolveContext context) { return((IEvent)Resolve(context)); }
public IType Resolve(ITypeResolveContext context) { return(new ByReferenceType(elementType.Resolve(context))); }
public override IMember CreateResolved(ITypeResolveContext context) { return(new DefaultResolvedEvent(this, context)); }
public static IList <IType> Resolve(this IList <ITypeReference> typeReferences, ITypeResolveContext context) { if (typeReferences == null) { throw new ArgumentNullException("typeReferences"); } if (typeReferences.Count == 0) { return(EmptyList <IType> .Instance); } else { return(new ProjectedList <ITypeResolveContext, ITypeReference, IType>(context, typeReferences, (c, t) => t.Resolve(c))); } }
object IConstantValue.GetValue(ITypeResolveContext context) { Contract.Requires(context != null); return(null); }
public IType Resolve(ITypeResolveContext context) { return(this); }
MemberList GetMemberList() { var result = LazyInit.VolatileRead(ref this.memberList); if (result != null) { return(result); } List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); List <PartialMethodInfo> partialMethodInfos = null; bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var member in part.Members) { IUnresolvedMethod method = member as IUnresolvedMethod; if (method != null && method.IsPartial) { // Merge partial method declaration and implementation if (partialMethodInfos == null) { partialMethodInfos = new List <PartialMethodInfo>(); } PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart); PartialMethodInfo existingInfo = null; foreach (var info in partialMethodInfos) { if (newInfo.IsSameSignature(info, Compilation.NameComparer)) { existingInfo = info; break; } } if (existingInfo != null) { // Add the unresolved method to the PartialMethodInfo: existingInfo.AddPart(method, contextForPart); } else { partialMethodInfos.Add(newInfo); } } else { unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } } addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired; } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.EntityType == EntityType.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0])); } } result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos); return(LazyInit.GetOrSet(ref this.memberList, result)); }
public static IList <IParameter> CreateResolvedParameters(this IList <IUnresolvedParameter> parameters, ITypeResolveContext context) { if (parameters == null) { throw new ArgumentNullException("parameters"); } if (parameters.Count == 0) { return(EmptyList <IParameter> .Instance); } else { return(new ProjectedList <ITypeResolveContext, IUnresolvedParameter, IParameter>(context, parameters, (c, a) => a.CreateResolvedParameter(c))); } }
protected AbstractResolvedEntity(IUnresolvedEntity unresolved, ITypeResolveContext parentContext) { this.unresolved = unresolved ?? throw new ArgumentNullException("unresolved"); this.parentContext = parentContext ?? throw new ArgumentNullException("parentContext"); this.Attributes = unresolved.Attributes.CreateResolvedAttributes(parentContext); }
IField IUnresolvedField.Resolve(ITypeResolveContext context) { return((IField)Resolve(context)); }
IModule IModuleReference.Resolve(ITypeResolveContext context) { return(new MinimalCorlib(context.Compilation)); }
IMethod IUnresolvedMethod.Resolve(ITypeResolveContext context) { return((IMethod)Resolve(context)); }
IProperty IUnresolvedProperty.Resolve(ITypeResolveContext context) { return((IProperty)Resolve(context)); }
public Expression ResolveConstant(ITypeResolveContext context) { return(new ErrorExpression(type.Resolve(context))); }
public static IList <IAttribute> CreateResolvedAttributes(this IList <IUnresolvedAttribute> attributes, ITypeResolveContext context) { if (attributes == null) { throw new ArgumentNullException("attributes"); } if (attributes.Count == 0) { return(EmptyList <IAttribute> .Instance); } else { return(new ProjectedList <ITypeResolveContext, IUnresolvedAttribute, IAttribute>(context, attributes, (c, a) => a.CreateResolvedAttribute(c))); } }
internal static ITypeReference Substitute(ITypeReference type, TypeVisitor substitution, ITypeResolveContext context) { if (substitution == null) { return(type); } if (context != null) { return(type.Resolve(context).AcceptVisitor(substitution)); } else { return(SubstitutionTypeReference.Create(type, substitution)); } }
public IType Resolve(ITypeResolveContext context) { return(new ArrayType(context.Compilation, elementType.Resolve(context), dimensions)); }
internal SpecializedMember(IType declaringType, IMember memberDefinition, TypeVisitor substitution, ITypeResolveContext context) { if (declaringType == null) { throw new ArgumentNullException("declaringType"); } if (memberDefinition == null) { throw new ArgumentNullException("memberDefinition"); } this.declaringType = declaringType; this.memberDefinition = memberDefinition; this.returnType = Substitute(memberDefinition.ReturnType, substitution, context); }
internal GenericContext(ITypeResolveContext context) { this.ClassTypeParameters = context.CurrentTypeDefinition?.TypeParameters; this.MethodTypeParameters = (context.CurrentMember as IMethod)?.TypeParameters; }
internal CSharpAssembly(ICompilation compilation, CSharpProjectContent projectContent) { this.compilation = compilation; this.projectContent = projectContent; this.context = new SimpleTypeResolveContext(this); }
IAttribute IUnresolvedAttribute.CreateResolvedAttribute(ITypeResolveContext context) { return(secDecl.Resolve(context.CurrentAssembly)[index]); }
public bool?IsReferenceType(ITypeResolveContext context) { return(genericType.IsReferenceType(context)); }
public IEnumerable <IType> GetBaseTypes(ITypeResolveContext context) { Substitution substitution = new Substitution(typeArguments); return(genericType.GetBaseTypes(context).Select(t => t.AcceptVisitor(substitution))); }
public IType Resolve(ITypeResolveContext context) { return(context.Compilation.FindType(knownTypeCode)); }
// There is intentionally no Resolve() overload for IList<IMemberReference>: the resulting IList<Member> would // contains nulls when there are resolve errors. public static IList <ResolveResult> Resolve(this IList <IConstantValue> constantValues, ITypeResolveContext context) { if (constantValues == null) { throw new ArgumentNullException("constantValues"); } if (constantValues.Count == 0) { return(EmptyList <ResolveResult> .Instance); } else { return(new ProjectedList <ITypeResolveContext, IConstantValue, ResolveResult>(context, constantValues, (c, t) => t.Resolve(c))); } }