protected ClassSymbol(SymbolType type, string name, NamespaceSymbol parent) : base(type, name, parent) { _inheritanceDepth = -1; _minimizationDepth = -1; _transformationCookie = -1; }
protected TypeSymbol(SymbolType type, string name, NamespaceSymbol parent) : base(type, name, parent) { Debug.Assert(parent != null); _memberTable = new Dictionary<string, MemberSymbol>(); _members = new List<MemberSymbol>(); _applicationType = true; }
public SymbolSet() { _namespaces = new List<NamespaceSymbol>(); _namespaceMap = new Dictionary<string, NamespaceSymbol>(); _globalNamespace = new NamespaceSymbol(String.Empty, this); _globalNamespace.SetTransformedName(String.Empty); _namespaces.Add(_globalNamespace); _namespaceMap[String.Empty] = _globalNamespace; _systemNamespace = new NamespaceSymbol("System", this); _namespaces.Add(_systemNamespace); _namespaceMap["System"] = _systemNamespace; _resources = new Dictionary<string, Dictionary<string, ResXItem>>(StringComparer.OrdinalIgnoreCase); }
public static void GenerateScript(ScriptGenerator generator, NamespaceSymbol namespaceSymbol, Dictionary<string,bool> generatedNamespaces) { Debug.Assert(generator != null); Debug.Assert(namespaceSymbol != null); Debug.Assert(namespaceSymbol.HasApplicationTypes); ScriptTextWriter writer = generator.Writer; // First generate enums and interfaces which do not have cross-dependencies // (Classes for example, might have dependencies on enums) foreach (TypeSymbol type in namespaceSymbol.Types) { if (type.IsApplicationType) { if (type.IsTestType && (generator.Options.IncludeTests == false)) { continue; } string namespaceName = type.GeneratedNamespace; if ((namespaceName.Length != 0) && (generatedNamespaces.ContainsKey(namespaceName) == false)) { writer.Write("Type.registerNamespace('"); writer.Write(namespaceName); writer.Write("');"); writer.WriteNewLine(); writer.WriteNewLine(); generatedNamespaces[namespaceName] = true; } } if (type.IsApplicationType && ((type.Type == SymbolType.Enumeration) || (type.Type == SymbolType.Interface) || (type.Type == SymbolType.Record) || (type.Type == SymbolType.Resources))) { TypeGenerator.GenerateScript(generator, type); } } foreach (TypeSymbol type in namespaceSymbol.Types) { if (type.IsApplicationType && (type.Type == SymbolType.Class)) { if (type.IsTestType && (generator.Options.IncludeTests == false)) { continue; } TypeGenerator.GenerateScript(generator, type); } } }
public RecordSymbol(string name, NamespaceSymbol parent) : base(SymbolType.Record, name, parent) { }
public GenericParameterSymbol(int index, string name, bool typeParameter, NamespaceSymbol parent) : base(SymbolType.GenericParameter, name, parent) { _index = index; _typeParameter = typeParameter; }
private void CreateNamespace(string namespaceName) { if (namespaceName.IndexOf('.') > 0) { NamespaceSymbol namespaceSymbol = new NamespaceSymbol(namespaceName, this); _namespaces.Add(namespaceSymbol); _namespaceMap[namespaceName] = namespaceSymbol; } else { // Split up the namespace into its individual parts, and then // create namespace symbols for each sub-namespace leading up // to the full specified namespace string[] namespaceParts = namespaceName.Split('.'); for (int i = 0; i < namespaceParts.Length; i++) { string partialNamespace; if (i == 0) { partialNamespace = namespaceParts[0]; } else { partialNamespace = String.Join(".", namespaceParts, 0, i + 1); } NamespaceSymbol namespaceSymbol = new NamespaceSymbol(partialNamespace, this); _namespaces.Add(namespaceSymbol); _namespaceMap[namespaceName] = namespaceSymbol; } } }
public GenericTypeSymbol(int genericArgumentIndex, NamespaceSymbol parent) : base(SymbolType.GenericParameter, "<T>", parent) { _genericArgumentIndex = genericArgumentIndex; }
public EnumerationSymbol(string name, NamespaceSymbol parent, bool flags) : base(SymbolType.Enumeration, name, parent) { _flags = flags; _transformationCookie = -1; }
public InterfaceSymbol(string name, NamespaceSymbol parent) : base(SymbolType.Interface, name, parent) { }
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); }
/// <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.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.Dictionary: mappedTypeName = "Dictionary"; mappedNamespace = "System.Collections"; 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.Type: mappedTypeName = "Type"; break; case IntrinsicType.IEnumerator: 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); }
private void DumpNamespace(NamespaceSymbol namespaceSymbol) { _writer.Write("HasApplicationTypes: "); _writer.WriteLine(namespaceSymbol.HasApplicationTypes); _writer.WriteLine("Types:"); _writer.Indent++; ArrayList types = new ArrayList(namespaceSymbol.Types.Count); foreach (TypeSymbol type in namespaceSymbol.Types) { types.Add(type); } types.Sort(new SymbolComparer()); foreach (TypeSymbol type in types) { DumpSymbol(type); } _writer.Indent--; }
public ClassSymbol(string name, NamespaceSymbol parent) : this(SymbolType.Class, name, parent) { }
public DelegateSymbol(string name, NamespaceSymbol parent) : base(SymbolType.Delegate, name, parent) { }
public ResourcesSymbol(string name, NamespaceSymbol parent) : base(SymbolType.Resources, name, parent) { }
private TypeSymbol BuildType(UserTypeNode typeNode, NamespaceSymbol namespaceSymbol) { Debug.Assert(typeNode != null); Debug.Assert(namespaceSymbol != null); TypeSymbol typeSymbol = null; ParseNodeList attributes = typeNode.Attributes; if (typeNode.Type == TokenType.Class) { CustomTypeNode customTypeNode = (CustomTypeNode)typeNode; Debug.Assert(customTypeNode != null); NameNode baseTypeNameNode = null; if (customTypeNode.BaseTypes.Count != 0) { baseTypeNameNode = customTypeNode.BaseTypes[0] as NameNode; } if ((baseTypeNameNode != null) && (String.CompareOrdinal(baseTypeNameNode.Name, "Record") == 0)) { typeSymbol = new RecordSymbol(typeNode.Name, namespaceSymbol); } else { AttributeNode resourcesAttribute = AttributeNode.FindAttribute(attributes, "Resources"); if (resourcesAttribute != null) { typeSymbol = new ResourcesSymbol(typeNode.Name, namespaceSymbol); } else { typeSymbol = new ClassSymbol(typeNode.Name, namespaceSymbol); if ((baseTypeNameNode != null) && (String.CompareOrdinal(baseTypeNameNode.Name, "TestClass") == 0)) { ((ClassSymbol)typeSymbol).SetTestClass(); } } } } else if (typeNode.Type == TokenType.Interface) { typeSymbol = new InterfaceSymbol(typeNode.Name, namespaceSymbol); } else if (typeNode.Type == TokenType.Enum) { bool flags = false; AttributeNode flagsAttribute = AttributeNode.FindAttribute(typeNode.Attributes, "Flags"); if (flagsAttribute != null) { flags = true; } typeSymbol = new EnumerationSymbol(typeNode.Name, namespaceSymbol, flags); } else if (typeNode.Type == TokenType.Delegate) { typeSymbol = new DelegateSymbol(typeNode.Name, namespaceSymbol); typeSymbol.SetTransformedName("Function"); typeSymbol.SetIgnoreNamespace(); } Debug.Assert(typeSymbol != null, "Unexpected type node " + typeNode.Type); if (typeSymbol != null) { if ((typeNode.Modifiers & Modifiers.Public) != 0) { typeSymbol.SetPublic(); } BuildType(typeSymbol, typeNode); if (namespaceSymbol.Name.EndsWith(_options.TestsSubnamespace, StringComparison.Ordinal)) { typeSymbol.SetTestType(); } } return typeSymbol; }