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