InvocationResolveResult GetCtorInvocation() { ResolveResult rr = this.ctorInvocation; if (rr != null) { LazyInit.ReadBarrier(); return(rr as InvocationResolveResult); } else { CSharpResolver resolver = new CSharpResolver(context); int totalArgumentCount = unresolved.positionalArguments.Count + unresolved.namedCtorArguments.Count; ResolveResult[] arguments = new ResolveResult[totalArgumentCount]; string[] argumentNames = new string[totalArgumentCount]; int i = 0; while (i < unresolved.positionalArguments.Count) { IConstantValue cv = unresolved.positionalArguments[i]; arguments[i] = cv.Resolve(context); i++; } foreach (var pair in unresolved.namedCtorArguments) { argumentNames[i] = pair.Key; arguments[i] = pair.Value.Resolve(context); i++; } rr = resolver.ResolveObjectCreation(attributeType, arguments, argumentNames); return(LazyInit.GetOrSet(ref this.ctorInvocation, rr) as InvocationResolveResult); } }
public IType FindType(KnownTypeCode typeCode) { IType type = knownTypes[(int)typeCode]; if (type != null) { LazyInit.ReadBarrier(); return(type); } return(LazyInit.GetOrSet(ref knownTypes[(int)typeCode], SearchType(typeCode))); }
Dictionary<string, INamespace> GetChildNamespaces() { var result = this.childNamespaces; if (result != null) { LazyInit.ReadBarrier(); return result; } else { result = new Dictionary<string, INamespace>(compilation.NameComparer); foreach (var g in namespaces.SelectMany(ns => ns.ChildNamespaces).GroupBy(ns => ns.Name, compilation.NameComparer)) { result.Add(g.Key, new MergedNamespace(this, g.ToArray())); } return LazyInit.GetOrSet(ref this.childNamespaces, result); } }
Dictionary <FullNameAndTypeParameterCount, DefaultResolvedTypeDefinition> GetTypes() { var dict = this.typeDict; if (dict != null) { LazyInit.ReadBarrier(); return(dict); } else { var comparer = FullNameAndTypeParameterCountComparer.Ordinal; dict = projectContent.TopLevelTypeDefinitions .GroupBy(t => new FullNameAndTypeParameterCount(t.Namespace, t.Name, t.TypeParameters.Count), comparer) .ToDictionary(g => g.Key, g => new DefaultResolvedTypeDefinition(context, g.ToArray()), comparer); return(LazyInit.GetOrSet(ref this.typeDict, dict)); } }
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor) { if (unresolvedAccessor == null) { return(null); } IMethod result = accessorField; if (result != null) { LazyInit.ReadBarrier(); return(result); } else { return(LazyInit.GetOrSet(ref accessorField, (IMethod)unresolvedAccessor.CreateResolved(context))); } }
IList <IAttribute> GetAttributes(ref IList <IAttribute> field, bool assemblyAttributes) { IList <IAttribute> result = field; if (result != null) { LazyInit.ReadBarrier(); return(result); } else { result = new List <IAttribute>(); foreach (var parsedFile in projectContent.Files.OfType <CSharpParsedFile>()) { var attributes = assemblyAttributes ? parsedFile.AssemblyAttributes : parsedFile.ModuleAttributes; var context = new CSharpTypeResolveContext(this, parsedFile.RootUsingScope.Resolve(compilation)); foreach (var unresolvedAttr in attributes) { result.Add(unresolvedAttr.CreateResolvedAttribute(context)); } } return(LazyInit.GetOrSet(ref field, result)); } }