public EnumerationSymbol(string name, NamespaceSymbol parent, bool flags)
: base(SymbolType.Enumeration, name, parent)
{
Flags = flags;
TransformationCookie = -1;
}
/// <summary>
/// This maps C# intrinsic types (managed types that have an equivalent
/// C# keyword)
/// </summary>
public TypeSymbol ResolveIntrinsicType(IntrinsicType type)
{
string mappedTypeName = null;
string mappedNamespace = null;
switch (type)
{
case IntrinsicType.Object:
mappedTypeName = "Object";
break;
case IntrinsicType.Boolean:
mappedTypeName = "Boolean";
break;
case IntrinsicType.String:
mappedTypeName = "String";
break;
case IntrinsicType.Integer:
mappedTypeName = "Int32";
break;
case IntrinsicType.UnsignedInteger:
mappedTypeName = "UInt32";
break;
case IntrinsicType.Long:
mappedTypeName = "Int64";
break;
case IntrinsicType.UnsignedLong:
mappedTypeName = "UInt64";
break;
case IntrinsicType.Short:
mappedTypeName = "Int16";
break;
case IntrinsicType.UnsignedShort:
mappedTypeName = "UInt16";
break;
case IntrinsicType.Byte:
mappedTypeName = "Byte";
break;
case IntrinsicType.SignedByte:
mappedTypeName = "SByte";
break;
case IntrinsicType.Single:
mappedTypeName = "Single";
break;
case IntrinsicType.Date:
mappedTypeName = "Date";
break;
case IntrinsicType.Decimal:
mappedTypeName = "Decimal";
break;
case IntrinsicType.Double:
mappedTypeName = "Double";
break;
case IntrinsicType.Delegate:
mappedTypeName = "Delegate";
break;
case IntrinsicType.Function:
mappedTypeName = "Function";
break;
case IntrinsicType.Void:
mappedTypeName = "Void";
break;
case IntrinsicType.Array:
mappedTypeName = "Array";
break;
case IntrinsicType.GenericList:
mappedTypeName = "List`1";
mappedNamespace = "System.Collections.Generic";
break;
case IntrinsicType.GenericDictionary:
mappedTypeName = "Dictionary`2";
mappedNamespace = "System.Collections.Generic";
break;
case IntrinsicType.IDictionary:
mappedTypeName = "IDictionary";
mappedNamespace = "System.Collections";
break;
case IntrinsicType.GenericIDictionary:
mappedTypeName = "IDictionary`2";
mappedNamespace = "System.Collections.Generic";
break;
case IntrinsicType.GenericIReadOnlyDictionary:
mappedTypeName = "IReadOnlyDictionary`2";
mappedNamespace = "System.Collections.Generic";
break;
case IntrinsicType.Type:
mappedTypeName = "Type";
mappedNamespace = "System";
break;
case IntrinsicType.MemberInfo:
mappedTypeName = "MemberInfo";
mappedNamespace = "System.Reflection";
break;
case IntrinsicType.Enumerator:
mappedTypeName = "IEnumerator";
mappedNamespace = "System.Collections";
break;
case IntrinsicType.Enum:
mappedTypeName = "Enum";
break;
case IntrinsicType.Exception:
mappedTypeName = "Exception";
break;
case IntrinsicType.Script:
mappedTypeName = "Script";
break;
case IntrinsicType.Number:
mappedTypeName = "Number";
break;
case IntrinsicType.Arguments:
mappedTypeName = "Arguments";
break;
case IntrinsicType.Nullable:
mappedTypeName = "Nullable`1";
break;
default:
Debug.Fail("Unmapped intrinsic type " + type);
break;
}
NamespaceSymbol ns = SystemNamespace;
if (mappedNamespace != null)
{
ns = GetNamespace(mappedNamespace);
Debug.Assert(ns != null);
}
if (mappedTypeName != null)
{
TypeSymbol typeSymbol =
(TypeSymbol)((ISymbolTable)ns).FindSymbol(mappedTypeName, null, SymbolFilter.Types);
Debug.Assert(typeSymbol != null);
return(typeSymbol);
}
return(null);
}
public InterfaceSymbol(string name, NamespaceSymbol parent)
: base(SymbolType.Interface, name, parent)
{
}
public Symbol FindSymbol(string name, Symbol context, SymbolFilter filter)
{
if ((filter & SymbolFilter.Types) == 0)
{
return(null);
}
Symbol symbol = null;
if (name.IndexOf('.') > 0)
{
symbol = FindSymbolFromNamespace(name, context);
}
else
{
Debug.Assert(context != null);
if (context is MethodSymbol methodContext)
{
GenericParameterSymbol genericType = FindGenericType(name, methodContext);
if (genericType != null)
{
return(genericType);
}
}
TypeSymbol typeSymbol = context as TypeSymbol;
if (typeSymbol == null)
{
Symbol parentSymbol = context.Parent;
while (parentSymbol != null)
{
typeSymbol = parentSymbol as TypeSymbol;
if (typeSymbol != null)
{
break;
}
parentSymbol = parentSymbol.Parent;
}
}
Debug.Assert(typeSymbol != null);
if (typeSymbol == null)
{
return(null);
}
if (typeSymbol.IsGeneric)
{
var resolved = typeSymbol.GenericParameters.FirstOrDefault(param => param.Name == name);
if (resolved != null)
{
return(resolved);
}
}
bool systemNamespaceChecked = false;
NamespaceSymbol containerNamespace = (NamespaceSymbol)typeSymbol.Parent;
Debug.Assert(containerNamespace != null);
symbol = ((ISymbolTable)containerNamespace).FindSymbol(name, /* context */ typeSymbol, SymbolFilter.Types);
if (containerNamespace == SystemNamespace)
{
systemNamespaceChecked = true;
}
if (symbol == null)
{
if (typeSymbol.Aliases != null && typeSymbol.Aliases.ContainsKey(name))
{
string typeReference = typeSymbol.Aliases[name];
symbol = ((ISymbolTable)this).FindSymbol(typeReference, /* context */ null,
SymbolFilter.Types);
}
else if (typeSymbol.Imports != null)
{
foreach (string importedNamespaceReference in typeSymbol.Imports)
{
if (namespaceMap.ContainsKey(importedNamespaceReference) == false)
{
// Since we included all parent namespaces of the current type's
// namespace, we might run into a namespace that doesn't contain
// any defined types, i.e. doesn't exist.
continue;
}
NamespaceSymbol importedNamespace = namespaceMap[importedNamespaceReference];
if (importedNamespace == containerNamespace)
{
continue;
}
symbol = ((ISymbolTable)importedNamespace).FindSymbol(name, /* context */ null,
SymbolFilter.Types);
if (importedNamespace == SystemNamespace)
{
systemNamespaceChecked = true;
}
if (symbol != null)
{
break;
}
}
}
}
if (symbol == null && systemNamespaceChecked == false)
{
symbol = ((ISymbolTable)SystemNamespace).FindSymbol(name, /* context */ null, SymbolFilter.Types);
}
if (symbol == null)
{
symbol = ((ISymbolTable)GlobalNamespace).FindSymbol(name, /* context */ null, SymbolFilter.Types);
}
}
return(symbol);
}
