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