object TryGetMemberCached(Namescope namescope, string name, int?typeParamCount)
{
var key = new NamescopeKey(namescope, name, typeParamCount ?? 0);
object result;
if (!_scopeMembers.TryGetValue(key, out result))
{
result = TryGetMemberInternal(namescope, name, typeParamCount);
_scopeMembers[key] = result;
}
return(result);
}
public Namespace GetNamespace(Namespace parent, string name)
{
var key = new NamescopeKey(parent, name);
object result;
if (!_scopeMembers.TryGetValue(key, out result))
{
result = new Namespace(parent, name);
_scopeMembers[key] = result;
parent.Namespaces.Add((Namespace)result);
}
return((Namespace)result);
}
internal object TryGetTypeMemberCached(DataType dt, string name, int?typeParamCount)
{
var key = new NamescopeKey(dt, name, typeParamCount ?? 0);
object result;
if (!_typeMembers.TryGetValue(key, out result))
{
result = TryGetTypeMemberInternal(dt, name, typeParamCount);
if (!dt.Stats.HasFlag(EntityStats.PopulatingMembers) || result != null)
{
_typeMembers[key] = result;
}
}
return(result);
}
List <NamespaceUsings> GetUsingsList(Namescope namescope, Source src)
{
var key = new NamescopeKey(namescope, src.FullPath, src.Part);
List <NamespaceUsings> list;
if (!_usings.TryGetValue(key, out list))
{
list = namescope.NamescopeType == NamescopeType.Namespace
? new List <NamespaceUsings>()
: GetUsingsList(namescope.Parent, src);
_usings.Add(key, list);
}
return(list);
}
public void AddUsings(List <AstILNode> nodes, ICollection <Namespace> parentNamespaces, ICollection <DataType> parentTypes)
{
foreach (var node in nodes)
{
var key = new NamescopeKey(node.IL, node.Ast.Name.Source.FullPath, node.Ast.Name.Source.Part);
var result = new NamespaceUsings(node.Ast.Name.Source.Line, parentNamespaces, parentTypes);
_usings.Add(key, result);
foreach (var directive in node.Ast.Usings)
{
var partial = ResolveExpression(node.IL, directive.Expression, null);
if (partial.IsInvalid)
{
continue;
}
switch (partial.ExpressionType)
{
case PartialExpressionType.Type:
{
var dt = ((PartialType)partial).Type;
switch (dt.TypeType)
{
case TypeType.Class:
case TypeType.Struct:
break;
default:
Log.Error(directive.Expression.Source, ErrorCode.E0000, "Invalid 'using' on " + dt.TypeType.ToString().ToLower());
continue;
}
if (dt.IsFlattenedDefinition)
{
Log.Error(directive.Expression.Source, ErrorCode.E0000, "Invalid 'using' on a generic type definition");
continue;
}
result.Types.Add(dt);
break;
}
case PartialExpressionType.Namespace:
{
var ns = ((PartialNamespace)partial).Namespace;
for (Namescope parent = node.IL;
parent != null;
parent = parent.Parent)
{
if (ns == parent)
{
Log.Error(directive.Expression.Source, ErrorCode.E0000, "Invalid 'using' on a parent namespace");
}
}
result.Namespaces.Add(ns);
break;
}
default:
{
Log.Error(directive.Expression.Source, ErrorCode.E0000, "Invalid 'using' on " + partial.Quote());
break;
}
}
}
AddUsings(node.Nodes, result.Namespaces, result.Types);
}
}
