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 void GenerateScript(SymbolSet symbolSet) { Debug.Assert(symbolSet != null); Dictionary <string, bool> generatedNamespaces = new Dictionary <string, bool>(); foreach (NamespaceSymbol namespaceSymbol in symbolSet.Namespaces) { if (namespaceSymbol.HasApplicationTypes) { NamespaceGenerator.GenerateScript(this, namespaceSymbol, generatedNamespaces); } } List <ClassSymbol> generatedClasses = new List <ClassSymbol>(_classes.Count); foreach (ClassSymbol generatedClass in _classes) { if (generatedClass.HasGlobalMethods == false) { GenerateClassRegistration(generatedClass, generatedClasses); } } // TODO: Couple of line-breaks would be nice here // but only if there are any classes with static // ctors or members foreach (ClassSymbol generatedClass in _classes) { TypeGenerator.GenerateClassConstructorScript(this, generatedClass); } if (Options.IncludeTests) { foreach (ClassSymbol generatedClass in _classes) { if (generatedClass.IsTestClass) { TestGenerator.GenerateScript(this, generatedClass); } } } }
private void GenerateClassRegistration(ClassSymbol classSymbol, List <ClassSymbol> generatedClasses) { Debug.Assert(classSymbol != null); if (generatedClasses.Contains(classSymbol)) { return; } ClassSymbol baseClass = classSymbol.BaseClass; if ((baseClass != null) && baseClass.IsApplicationType) { GenerateClassRegistration(baseClass, generatedClasses); } TypeGenerator.GenerateClassRegistrationScript(this, classSymbol); generatedClasses.Add(classSymbol); }
public void GenerateScript(SymbolSet symbolSet) { Debug.Assert(symbolSet != null); List <TypeSymbol> types = new List <TypeSymbol>(); List <TypeSymbol> publicTypes = new List <TypeSymbol>(); List <TypeSymbol> internalTypes = new List <TypeSymbol>(); bool hasNonModuleInternalTypes = false; foreach (NamespaceSymbol namespaceSymbol in symbolSet.Namespaces) { if (namespaceSymbol.HasApplicationTypes) { foreach (TypeSymbol type in namespaceSymbol.Types) { if (type.IsApplicationType == false) { continue; } if (type.Type == SymbolType.Delegate) { // Nothing needs to be generated for delegate types. continue; } if (type.IsTestType && (_options.IncludeTests == false)) { continue; } if ((type.Type == SymbolType.Enumeration) && ((type.IsPublic == false) || ((EnumerationSymbol)type).Constants)) { // Internal enums can be skipped since their values have been inlined. // Public enums marked as constants can also be skipped since their // values will always be inlined. continue; } types.Add(type); if (type.IsPublic) { publicTypes.Add(type); } else { if ((type.Type != SymbolType.Class) || (((ClassSymbol)type).IsModuleClass == false)) { hasNonModuleInternalTypes = true; } internalTypes.Add(type); } } } } // Sort the types, so similar types of types are grouped, and parent classes // come before derived classes. IComparer <TypeSymbol> typeComparer = new TypeComparer(); types = types.OrderBy(t => t, typeComparer).ToList(); publicTypes = publicTypes.OrderBy(t => t, typeComparer).ToList(); internalTypes = internalTypes.OrderBy(t => t, typeComparer).ToList(); bool initialIndent = false; if (String.IsNullOrEmpty(_options.ScriptInfo.Template) == false) { int scriptIndex = _options.ScriptInfo.Template.IndexOf("{script}"); if ((scriptIndex > 0) && (_options.ScriptInfo.Template[scriptIndex - 1] == ' ')) { // Heuristic to turn on initial indent: // The script template has a space prior to {script}, i.e. {script} is not the // first thing on a line within the template. initialIndent = true; } } if (initialIndent) { _writer.Indent++; } foreach (TypeSymbol type in types) { TypeGenerator.GenerateScript(this, type); } bool generateModule = (publicTypes.Count != 0) || ((internalTypes.Count != 0) && hasNonModuleInternalTypes); if (generateModule) { _writer.Write("var $exports = ss.module('"); _writer.Write(symbolSet.ScriptName); _writer.Write("',"); if ((internalTypes.Count != 0) && hasNonModuleInternalTypes) { _writer.WriteLine(); _writer.Indent++; _writer.WriteLine("{"); _writer.Indent++; bool firstType = true; foreach (TypeSymbol type in internalTypes) { if ((type.Type == SymbolType.Class) && (((ClassSymbol)type).IsExtenderClass || ((ClassSymbol)type).IsModuleClass)) { continue; } if ((type.Type == SymbolType.Record) && ((RecordSymbol)type).Constructor == null) { continue; } if (firstType == false) { _writer.WriteLine(","); } TypeGenerator.GenerateRegistrationScript(this, type); firstType = false; } _writer.Indent--; _writer.WriteLine(); _writer.Write("},"); _writer.Indent--; } else { _writer.Write(" null,"); } if (publicTypes.Count != 0) { _writer.WriteLine(); _writer.Indent++; _writer.WriteLine("{"); _writer.Indent++; bool firstType = true; foreach (TypeSymbol type in publicTypes) { if ((type.Type == SymbolType.Class) && ((ClassSymbol)type).IsExtenderClass) { continue; } if (firstType == false) { _writer.WriteLine(","); } TypeGenerator.GenerateRegistrationScript(this, type); firstType = false; } _writer.Indent--; _writer.WriteLine(); _writer.Write("}"); _writer.Indent--; } else { _writer.Write(" null"); } _writer.WriteLine(");"); _writer.WriteLine(); } foreach (TypeSymbol type in types) { if (type.Type == SymbolType.Class) { TypeGenerator.GenerateClassConstructorScript(this, (ClassSymbol)type); } } if (_options.IncludeTests) { foreach (TypeSymbol type in types) { ClassSymbol classSymbol = type as ClassSymbol; if ((classSymbol != null) && classSymbol.IsTestClass) { TestGenerator.GenerateScript(this, classSymbol); } } } if (initialIndent) { _writer.Indent--; } }