protected Symbol(SymbolType type, string name, Symbol parent)
{
_type = type;
_name = name;
_parent = parent;
_transformAllowed = true;
}
public static void GenerateComment(ScriptGenerator generator, Symbol symbol) {
ScriptTextWriter writer = generator.Writer;
switch (symbol.Type) {
case SymbolType.Class:
GenerateClassComment(writer, (ClassSymbol)symbol);
break;
case SymbolType.Enumeration:
GenerateEnumerationComment(writer, (EnumerationSymbol)symbol);
break;
case SymbolType.Event:
GenerateEventComment(writer, (EventSymbol)symbol);
break;
case SymbolType.Indexer:
GenerateIndexerComment(writer, (IndexerSymbol)symbol);
break;
case SymbolType.Interface:
GenerateInterfaceComment(writer, (InterfaceSymbol)symbol);
break;
case SymbolType.Method:
GenerateMethodComment(writer, (MethodSymbol)symbol);
break;
case SymbolType.Property:
GeneratePropertyComment(writer, (PropertySymbol)symbol);
break;
default:
Debug.Fail("Unexpected symbol type");
break;
}
}
public ExpressionBuilder(ILocalSymbolTable symbolTable, FieldSymbol fieldContext, IErrorHandler errorHandler, CompilerOptions options) {
_symbolTable = symbolTable;
_symbolContext = fieldContext;
_classContext = ((ClassSymbol)fieldContext.Parent).PrimaryPartialClass;
_symbolSet = fieldContext.SymbolSet;
_errorHandler = errorHandler;
_options = options;
}
Symbol ISymbolTable.FindSymbol(string name, Symbol context, SymbolFilter filter) {
Debug.Assert(String.IsNullOrEmpty(name) == false);
Debug.Assert(context == null);
Debug.Assert(filter == SymbolFilter.Types);
if (_typeMap.ContainsKey(name)) {
return _typeMap[name];
}
return null;
}
Symbol ISymbolTable.FindSymbol(string name, Symbol context, SymbolFilter filter) {
Symbol symbol = null;
if ((filter & SymbolFilter.Locals) != 0) {
if (_localTable.ContainsKey(name)) {
symbol = _localTable[name];
}
}
if (symbol == null) {
Debug.Assert(_parentSymbolTable != null);
symbol = _parentSymbolTable.FindSymbol(name, context, filter);
}
return symbol;
}
string ISymbolTransformer.TransformSymbol(Symbol symbol, out bool transformChildren) {
transformChildren = false;
if (symbol is TypeSymbol) {
if ((symbol.Type == SymbolType.Class) && ((ClassSymbol)symbol).IsTestType) {
return null;
}
return TransformType((TypeSymbol)symbol, out transformChildren);
}
else if (symbol is MemberSymbol) {
return TransformMember((MemberSymbol)symbol);
}
return null;
}
Symbol ISymbolTable.FindSymbol(string name, Symbol context, SymbolFilter filter)
{
Debug.Assert(_currentScope != null);
return ((ISymbolTable)_currentScope).FindSymbol(name, context, filter);
}
Symbol ISymbolTable.FindSymbol(string name, Symbol context, SymbolFilter filter) {
Debug.Assert(String.IsNullOrEmpty(name) == false);
Debug.Assert(context != null);
Symbol symbol = null;
if ((filter & SymbolFilter.Members) != 0) {
SymbolFilter baseFilter = filter | SymbolFilter.ExcludeParent;
symbol = GetMember(name);
if (symbol == null) {
TypeSymbol baseType = GetBaseType();
TypeSymbol objectType = (TypeSymbol)((ISymbolTable)this.SymbolSet.SystemNamespace).FindSymbol("Object", null, SymbolFilter.Types);
if ((baseType == null) && (this != objectType)) {
baseType = objectType;
}
if (baseType != null) {
symbol = ((ISymbolTable)baseType).FindSymbol(name, context, baseFilter);
}
}
if ((symbol != null) && (symbol.MatchFilter(filter) == false)) {
symbol = null;
}
}
if ((symbol == null) && (_parentSymbolTable != null) &&
((filter & SymbolFilter.ExcludeParent) == 0)) {
symbol = _parentSymbolTable.FindSymbol(name, context, filter);
}
return symbol;
}
private static void GenerateSummaryComment(ScriptTextWriter writer, Symbol symbol) {
string documentation = symbol.Documentation;
if (String.IsNullOrEmpty(documentation) == false) {
writer.WriteLine("/// <summary>");
GenerateFormattedComment(writer, documentation);
writer.WriteLine("/// </summary>");
}
}
public TypeSymbol ResolveType(ParseNode node, ISymbolTable symbolTable, Symbol contextSymbol)
{
if (node is IntrinsicTypeNode) {
IntrinsicType intrinsicType = IntrinsicType.Integer;
IntrinsicTypeNode intrinsicTypeNode = (IntrinsicTypeNode)node;
switch (intrinsicTypeNode.Type) {
case TokenType.Object:
intrinsicType = IntrinsicType.Object;
break;
case TokenType.Bool:
intrinsicType = IntrinsicType.Boolean;
break;
case TokenType.String:
case TokenType.Char:
intrinsicType = IntrinsicType.String;
break;
case TokenType.Int:
intrinsicType = IntrinsicType.Integer;
break;
case TokenType.UInt:
intrinsicType = IntrinsicType.UnsignedInteger;
break;
case TokenType.Long:
intrinsicType = IntrinsicType.Long;
break;
case TokenType.ULong:
intrinsicType = IntrinsicType.UnsignedLong;
break;
case TokenType.Short:
intrinsicType = IntrinsicType.Short;
break;
case TokenType.UShort:
intrinsicType = IntrinsicType.UnsignedShort;
break;
case TokenType.Byte:
intrinsicType = IntrinsicType.Byte;
break;
case TokenType.SByte:
intrinsicType = IntrinsicType.SignedByte;
break;
case TokenType.Float:
intrinsicType = IntrinsicType.Single;
break;
case TokenType.Decimal:
intrinsicType = IntrinsicType.Decimal;
break;
case TokenType.Double:
intrinsicType = IntrinsicType.Double;
break;
case TokenType.Delegate:
intrinsicType = IntrinsicType.Delegate;
break;
case TokenType.Void:
intrinsicType = IntrinsicType.Void;
break;
}
TypeSymbol typeSymbol = ResolveIntrinsicType(intrinsicType);
if (intrinsicTypeNode.IsNullable) {
TypeSymbol nullableType = ResolveIntrinsicType(IntrinsicType.Nullable);
typeSymbol = CreateGenericTypeSymbol(nullableType, new List<TypeSymbol>() { typeSymbol });
}
return typeSymbol;
}
else if (node is ArrayTypeNode) {
ArrayTypeNode arrayTypeNode = (ArrayTypeNode)node;
TypeSymbol itemTypeSymbol = ResolveType(arrayTypeNode.BaseType, symbolTable, contextSymbol);
Debug.Assert(itemTypeSymbol != null);
return CreateArrayTypeSymbol(itemTypeSymbol);
}
else if (node is GenericNameNode) {
GenericNameNode genericNameNode = (GenericNameNode)node;
string genericTypeName = genericNameNode.Name + "`" + genericNameNode.TypeArguments.Count;
TypeSymbol templateType = (TypeSymbol)symbolTable.FindSymbol(genericTypeName, contextSymbol, SymbolFilter.Types);
List<TypeSymbol> typeArguments = new List<TypeSymbol>();
foreach (ParseNode argNode in genericNameNode.TypeArguments) {
TypeSymbol argType = ResolveType(argNode, symbolTable, contextSymbol);
typeArguments.Add(argType);
}
TypeSymbol resolvedSymbol = CreateGenericTypeSymbol(templateType, typeArguments);
Debug.Assert(resolvedSymbol != null);
return resolvedSymbol;
}
else {
Debug.Assert(node is NameNode);
NameNode nameNode = (NameNode)node;
return (TypeSymbol)symbolTable.FindSymbol(nameNode.Name, contextSymbol, SymbolFilter.Types);
}
}
Symbol ISymbolTable.FindSymbol(string name, Symbol context, SymbolFilter filter)
{
if ((filter & SymbolFilter.Types) == 0) {
return null;
}
Symbol symbol = null;
if (name.IndexOf('.') > 0) {
int nameIndex = name.LastIndexOf('.') + 1;
Debug.Assert(nameIndex < name.Length);
string namespaceName = name.Substring(0, nameIndex - 1);
name = name.Substring(nameIndex);
NamespaceSymbol namespaceSymbol;
if (_namespaceMap.TryGetValue(namespaceName, out namespaceSymbol)) {
symbol = ((ISymbolTable)namespaceSymbol).FindSymbol(name, /* context */ null, SymbolFilter.Types);
}
}
else {
Debug.Assert(context != null);
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;
}
bool systemNamespaceChecked = false;
NamespaceSymbol containerNamespace = (NamespaceSymbol)typeSymbol.Parent;
Debug.Assert(containerNamespace != null);
symbol = ((ISymbolTable)containerNamespace).FindSymbol(name, /* context */ null, 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;
}
private void DumpSymbol(Symbol symbol)
{
_writer.Write(symbol.Type.ToString());
_writer.Write(": ");
_writer.WriteLine(symbol.Name);
switch (symbol.Type) {
case SymbolType.Namespace:
DumpNamespace((NamespaceSymbol)symbol);
break;
case SymbolType.Class:
case SymbolType.Interface:
case SymbolType.Enumeration:
case SymbolType.Delegate:
case SymbolType.Record:
DumpType((TypeSymbol)symbol);
break;
case SymbolType.Field:
case SymbolType.EnumerationField:
case SymbolType.Constructor:
case SymbolType.Property:
case SymbolType.Indexer:
case SymbolType.Event:
case SymbolType.Method:
DumpMember((MemberSymbol)symbol);
break;
case SymbolType.Parameter:
DumpParameter((ParameterSymbol)symbol);
break;
}
}
