private void ImportEnumFields(TypeSymbol enumTypeSymbol) { TypeDefinition type = (TypeDefinition)enumTypeSymbol.MetadataReference; foreach (FieldDefinition field in type.Fields) { if (field.IsSpecialName) { continue; } Debug.Assert(enumTypeSymbol is EnumerationSymbol); EnumerationSymbol enumSymbol = (EnumerationSymbol)enumTypeSymbol; TypeSymbol fieldType; if (enumSymbol.UseNamedValues) { fieldType = symbols.ResolveIntrinsicType(IntrinsicType.String); } else { fieldType = symbols.ResolveIntrinsicType(IntrinsicType.Integer); } string fieldName = field.Name; EnumerationFieldSymbol fieldSymbol = new EnumerationFieldSymbol(fieldName, enumTypeSymbol, field.Constant, fieldType); ImportMemberDetails(fieldSymbol, null, field); enumTypeSymbol.AddMember(fieldSymbol); } }
private static string GetParameterTypeName(TypeSymbol parameterType) { var symbolSet = parameterType.SymbolSet; TypeSymbol nullableType = symbolSet.ResolveIntrinsicType(IntrinsicType.Nullable); if (parameterType.FullName == nullableType.FullName) { parameterType = parameterType.GenericArguments.First(); } TypeSymbol typeType = symbolSet.ResolveIntrinsicType(IntrinsicType.Type); TypeSymbol functionType = symbolSet.ResolveIntrinsicType(IntrinsicType.Function); if (parameterType.FullName == typeType.FullName || parameterType.Type == SymbolType.Delegate) { parameterType = functionType; } if (parameterType.Type == SymbolType.Enumeration) { EnumerationSymbol enumType = (EnumerationSymbol)parameterType; if (enumType.UseNamedValues) { TypeSymbol stringType = symbolSet.ResolveIntrinsicType(IntrinsicType.String); parameterType = stringType; } else { TypeSymbol numberType = symbolSet.ResolveIntrinsicType(IntrinsicType.Number); parameterType = numberType; } } return(parameterType.FullGeneratedName); }
public static object GetDefaultValue(TypeSymbol type, SymbolSet symbolSet) { if (type.Type == SymbolType.Enumeration) { // The default for named values is null, so this only applies to // regular enum types EnumerationSymbol enumType = (EnumerationSymbol)type; if (enumType.UseNamedValues == false) { return(0); } } else if (type == symbolSet.ResolveIntrinsicType(IntrinsicType.Integer) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedInteger) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.Long) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedLong) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.Short) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedShort) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.Byte) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.SignedByte) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.Double) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.Single) || type == symbolSet.ResolveIntrinsicType(IntrinsicType.Decimal)) { return(0); } else if (type == symbolSet.ResolveIntrinsicType(IntrinsicType.Boolean)) { return(false); } return(null); }
private static void GenerateEnumerationRegistrationScript( ScriptGenerator generator, EnumerationSymbol enumerationSymbol) { ScriptTextWriter writer = generator.Writer; writer.Write($"new {DSharpStringResources.ScriptExportMember("Enum")}("); writer.Write($"'{enumerationSymbol.FullGeneratedName}'"); writer.Write(", "); writer.Write(enumerationSymbol.FullGeneratedName); writer.Write(")"); }
private static void GenerateEnumeration(ScriptGenerator generator, EnumerationSymbol enumSymbol) { ScriptTextWriter writer = generator.Writer; string enumName = enumSymbol.FullGeneratedName; writer.Write("var "); writer.Write(enumName); writer.Write(" = new "); writer.Write(DSharpStringResources.ScriptExportMember("Enum")); writer.Write("('"); writer.Write(enumName); writer.Write("', "); writer.Write("{"); writer.Indent++; bool firstValue = true; foreach (MemberSymbol memberSymbol in enumSymbol.Members) { if (!(memberSymbol is EnumerationFieldSymbol fieldSymbol)) { continue; } if (firstValue == false) { writer.Write(", "); } writer.WriteLine(); writer.Write(fieldSymbol.GeneratedName); writer.Write(": "); if (enumSymbol.UseNamedValues) { writer.Write(Utility.QuoteString(enumSymbol.CreateNamedValue(fieldSymbol))); } else { writer.Write(fieldSymbol.Value); } firstValue = false; } writer.Indent--; writer.WriteLine(); writer.Write("});"); writer.WriteLine(); }
private static void GenerateEnumeration(ScriptGenerator generator, EnumerationSymbol enumSymbol) { ScriptTextWriter writer = generator.Writer; string enumName = enumSymbol.FullGeneratedName; writer.Write("var "); writer.Write(enumSymbol.FullGeneratedName); writer.Write(" = {"); writer.Indent++; bool firstValue = true; foreach (MemberSymbol memberSymbol in enumSymbol.Members) { EnumerationFieldSymbol fieldSymbol = memberSymbol as EnumerationFieldSymbol; if (fieldSymbol == null) { continue; } if (firstValue == false) { writer.Write(", "); } writer.WriteLine(); writer.Write(fieldSymbol.GeneratedName); writer.Write(": "); if (enumSymbol.UseNamedValues) { writer.Write(Utility.QuoteString(enumSymbol.CreateNamedValue(fieldSymbol))); } else { writer.Write(fieldSymbol.Value); } firstValue = false; } writer.Indent--; writer.WriteLine(); writer.Write("};"); writer.WriteLine(); }
private EnumerationFieldSymbol BuildEnumField(EnumerationFieldNode fieldNode, TypeSymbol typeSymbol) { Debug.Assert(typeSymbol is EnumerationSymbol); EnumerationSymbol enumSymbol = (EnumerationSymbol)typeSymbol; TypeSymbol fieldTypeSymbol; if (enumSymbol.UseNamedValues) { fieldTypeSymbol = _symbols.ResolveIntrinsicType(IntrinsicType.String); } else { fieldTypeSymbol = _symbols.ResolveIntrinsicType(IntrinsicType.Integer); } EnumerationFieldSymbol fieldSymbol = new EnumerationFieldSymbol(fieldNode.Name, typeSymbol, fieldNode.Value, fieldTypeSymbol); BuildMemberDetails(fieldSymbol, typeSymbol, fieldNode, fieldNode.Attributes); return(fieldSymbol); }
private static void GenerateEnumerationComment(ScriptTextWriter writer, EnumerationSymbol enumSymbol) { writer.WriteNewLine(); writer.Indent++; GenerateSummaryComment(writer, enumSymbol); foreach (MemberSymbol memberSymbol in enumSymbol.Members) { EnumerationFieldSymbol fieldSymbol = memberSymbol as EnumerationFieldSymbol; if (fieldSymbol != null) { writer.WriteLine( "/// <field name=\"{0}\" type=\"Number\" integer=\"true\" static=\"true\">", fieldSymbol.GeneratedName); GenerateFormattedComment(writer, fieldSymbol.Documentation); writer.WriteLine("/// </field>"); } } writer.Indent--; }
public SymbolImplementation BuildField(FieldSymbol fieldSymbol) { rootScope = new SymbolScope((ISymbolTable)fieldSymbol.Parent); currentScope = rootScope; Expression initializerExpression = null; FieldDeclarationNode fieldDeclarationNode = (FieldDeclarationNode)fieldSymbol.ParseContext; Debug.Assert(fieldDeclarationNode != null); VariableInitializerNode initializerNode = (VariableInitializerNode)fieldDeclarationNode.Initializers[0]; if (initializerNode.Value != null) { ExpressionBuilder expressionBuilder = new ExpressionBuilder(this, fieldSymbol, errorHandler, options); initializerExpression = expressionBuilder.BuildExpression(initializerNode.Value); if (initializerExpression is MemberExpression) { initializerExpression = expressionBuilder.TransformMemberExpression((MemberExpression)initializerExpression); } } else { object defaultValue = null; TypeSymbol fieldType = fieldSymbol.AssociatedType; SymbolSet symbolSet = fieldSymbol.SymbolSet; if (fieldType.Type == SymbolType.Enumeration) { // The default for named values is null, so this only applies to // regular enum types EnumerationSymbol enumType = (EnumerationSymbol)fieldType; if (enumType.UseNamedValues == false) { defaultValue = 0; } } else if (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Integer) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedInteger) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Long) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedLong) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Short) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedShort) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Byte) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.SignedByte) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Double) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Single) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Decimal)) { defaultValue = 0; } else if (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Boolean)) { defaultValue = false; } if (defaultValue != null) { initializerExpression = new LiteralExpression(symbolSet.ResolveIntrinsicType(IntrinsicType.Object), defaultValue); fieldSymbol.SetImplementationState(/* hasInitializer */ true); } } if (initializerExpression != null) { List <Statement> statements = new List <Statement>(); statements.Add(new ExpressionStatement(initializerExpression, /* isFragment */ true)); return(new SymbolImplementation(statements, null, "this")); } return(null); }
private static void GenerateEnumeration(ScriptGenerator generator, EnumerationSymbol enumSymbol) { ScriptTextWriter writer = generator.Writer; if (enumSymbol.Namespace.Length == 0) { writer.Write("window."); } writer.Write(enumSymbol.FullGeneratedName); writer.WriteTrimmed(" = "); writer.Write("function()"); writer.WriteTrimmed(" { "); if (generator.Options.EnableDocComments) { DocCommentGenerator.GenerateComment(generator, enumSymbol); } writer.Write("};"); writer.WriteNewLine(); writer.Write(enumSymbol.FullGeneratedName); writer.Write(".prototype = {"); writer.Indent++; bool firstValue = true; foreach (MemberSymbol memberSymbol in enumSymbol.Members) { EnumerationFieldSymbol fieldSymbol = memberSymbol as EnumerationFieldSymbol; if (fieldSymbol == null) { continue; } if (firstValue == false) { writer.WriteTrimmed(", "); } writer.WriteNewLine(); writer.Write(fieldSymbol.GeneratedName); writer.WriteTrimmed(": "); if (enumSymbol.UseNamedValues) { writer.Write(Utility.QuoteString(enumSymbol.CreateNamedValue(fieldSymbol))); } else { writer.Write(fieldSymbol.Value); } firstValue = false; } writer.Indent--; writer.WriteNewLine(); writer.WriteTrimmed("}"); writer.WriteSignificantNewLine(); writer.Write(enumSymbol.FullGeneratedName); writer.Write(".registerEnum('"); writer.Write(enumSymbol.FullGeneratedName); writer.WriteTrimmed("', "); writer.Write(enumSymbol.Flags ? "true" : "false"); writer.Write(");"); writer.WriteNewLine(); }
private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScriptCoreAssembly, bool inApplicationAssembly, ScriptReference dependency, TypeSymbol outerType = null) { if (!type.IsPublic && !type.IsNestedPublic && dependency?.InternalesVisible == false) { return; } if (inScriptCoreAssembly && MetadataHelpers.ShouldImportScriptCoreType(type) == false) { return; } string name = outerType is TypeSymbol ? $"{outerType.Name}${type.Name}" : type.Name; string namespaceName = outerType is TypeSymbol ? outerType.Namespace : type.Namespace; bool dummy; string scriptName = MetadataHelpers.GetScriptName(type, out dummy, out dummy); NamespaceSymbol namespaceSymbol = symbols.GetNamespace(namespaceName); TypeSymbol typeSymbol = null; if (type.IsInterface) { typeSymbol = new InterfaceSymbol(name, namespaceSymbol); } else if (MetadataHelpers.IsEnum(type)) { // NOTE: We don't care about the flags bit on imported enums // because this is only consumed by the generation logic. typeSymbol = new EnumerationSymbol(name, namespaceSymbol, /* flags */ false); if (MetadataHelpers.ShouldUseEnumNames(type)) { ((EnumerationSymbol)typeSymbol).SetNamedValues(); } else if (MetadataHelpers.ShouldUseEnumValues(type)) { ((EnumerationSymbol)typeSymbol).SetNumericValues(); } } else if (MetadataHelpers.IsDelegate(type)) { typeSymbol = new DelegateSymbol(name, namespaceSymbol); typeSymbol.SetTransformedName("Function"); typeSymbol.SetIgnoreGenerics(); typeSymbol.SetIgnoreNamespace(); } else { if (MetadataHelpers.ShouldTreatAsRecordType(type)) { typeSymbol = new RecordSymbol(name, namespaceSymbol); typeSymbol.SetTransformedName(nameof(Object)); } else { typeSymbol = new ClassSymbol(name, namespaceSymbol); } } if (typeSymbol != null) { if (MetadataHelpers.ShouldIgnoreGenerics(type, out var useGenericName)) { typeSymbol.SetIgnoreGenerics(useGenericName); } if (type.HasGenericParameters) { List <GenericParameterSymbol> genericArguments = new List <GenericParameterSymbol>(); foreach (GenericParameter genericParameter in type.GenericParameters) { GenericParameterSymbol arg = new GenericParameterSymbol(genericParameter.Position, genericParameter.Name, true, symbols.GlobalNamespace); genericArguments.Add(arg); } typeSymbol.AddGenericParameters(genericArguments); } string dependencyName = MetadataHelpers.GetScriptDependencyName(type, out string dependencyIdentifier); if (dependencyName != null) { dependency = ScriptReferenceProvider.Instance.GetReference(dependencyName, dependencyIdentifier); } if (!inApplicationAssembly) { typeSymbol.SetImported(dependency); } typeSymbol.SetMetadataToken(type, inScriptCoreAssembly); bool ignoreNamespace = MetadataHelpers.ShouldIgnoreNamespace(type); if (ignoreNamespace || dependency == null || string.IsNullOrEmpty(dependency.Identifier)) { typeSymbol.SetIgnoreNamespace(); } else { typeSymbol.ScriptNamespace = dependency.Identifier; } //todo: improve the logic here to support private/protected access modifiers for nested classes typeSymbol.IsPublic = type.IsPublic; typeSymbol.IsInternal = type.IsNotPublic; if (string.IsNullOrEmpty(scriptName) == false) { typeSymbol.SetTransformedName(scriptName); } SetArrayTypeMetadata(type, typeSymbol, scriptName); typeSymbol.SetSource(dependency); namespaceSymbol.AddType(typeSymbol); importedTypes.Add(typeSymbol); if (outerType is TypeSymbol) { outerType.AddType(typeSymbol); } if (type.HasNestedTypes) { foreach (TypeDefinition nestedType in type.NestedTypes) { ImportType(mdSource, nestedType, inScriptCoreAssembly, inApplicationAssembly, dependency, typeSymbol); } } } }
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); }
private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScriptCoreAssembly, string scriptNamespace) { if (type.IsPublic == false) { return; } if (inScriptCoreAssembly && (MetadataHelpers.ShouldImportScriptCoreType(type) == false)) { return; } string name = type.Name; string namespaceName = type.Namespace; bool dummy; string scriptName = MetadataHelpers.GetScriptName(type, out dummy, out dummy); NamespaceSymbol namespaceSymbol = _symbols.GetNamespace(namespaceName); TypeSymbol typeSymbol = null; if (type.IsInterface) { typeSymbol = new InterfaceSymbol(name, namespaceSymbol); } else if (MetadataHelpers.IsEnum(type)) { // NOTE: We don't care about the flags bit on imported enums // because this is only consumed by the generation logic. typeSymbol = new EnumerationSymbol(name, namespaceSymbol, /* flags */ false); if (MetadataHelpers.ShouldUseEnumNames(type)) { ((EnumerationSymbol)typeSymbol).SetNamedValues(); } else if (MetadataHelpers.ShouldUseEnumValues(type)) { ((EnumerationSymbol)typeSymbol).SetNumericValues(); } } else if (MetadataHelpers.IsDelegate(type)) { typeSymbol = new DelegateSymbol(name, namespaceSymbol); typeSymbol.SetTransformedName("Function"); } else { if (MetadataHelpers.ShouldTreatAsRecordType(type)) { typeSymbol = new RecordSymbol(name, namespaceSymbol); typeSymbol.SetTransformedName("Object"); } else { typeSymbol = new ClassSymbol(name, namespaceSymbol); string extendee; if (MetadataHelpers.IsScriptExtension(type, out extendee)) { ((ClassSymbol)typeSymbol).SetExtenderClass(extendee); } if (String.CompareOrdinal(scriptName, "Array") == 0) { typeSymbol.SetArray(); } } } if (typeSymbol != null) { if (type.HasGenericParameters) { List <GenericParameterSymbol> genericArguments = new List <GenericParameterSymbol>(); foreach (GenericParameter genericParameter in type.GenericParameters) { GenericParameterSymbol arg = new GenericParameterSymbol(genericParameter.Position, genericParameter.Name, /* typeArgument */ true, _symbols.GlobalNamespace); genericArguments.Add(arg); } typeSymbol.AddGenericParameters(genericArguments); } ScriptReference dependency = null; string dependencyIdentifier; string dependencyName = MetadataHelpers.GetScriptDependencyName(type, out dependencyIdentifier); if (dependencyName != null) { dependency = new ScriptReference(dependencyName, dependencyIdentifier); scriptNamespace = dependency.Identifier; } typeSymbol.SetImported(dependency); typeSymbol.SetMetadataToken(type, inScriptCoreAssembly); bool ignoreNamespace = MetadataHelpers.ShouldIgnoreNamespace(type); if (ignoreNamespace || String.IsNullOrEmpty(scriptNamespace)) { typeSymbol.SetIgnoreNamespace(); } else { typeSymbol.ScriptNamespace = scriptNamespace; } typeSymbol.SetPublic(); if (String.IsNullOrEmpty(scriptName) == false) { typeSymbol.SetTransformedName(scriptName); } namespaceSymbol.AddType(typeSymbol); _importedTypes.Add(typeSymbol); } }
private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScriptCoreAssembly, string assemblyScriptNamespace, string assemblyScriptName) { if (type.IsPublic == false) { return; } if (inScriptCoreAssembly && (MetadataHelpers.ShouldImportScriptCoreType(type) == false)) { return; } string name = type.Name; string namespaceName = type.Namespace; string scriptNamespace = MetadataHelpers.GetScriptNamespace(type); string scriptName = MetadataHelpers.GetScriptName(type); if (String.IsNullOrEmpty(scriptNamespace) && (String.IsNullOrEmpty(assemblyScriptNamespace) == false)) { scriptNamespace = assemblyScriptNamespace; } NamespaceSymbol namespaceSymbol = _symbols.GetNamespace(namespaceName); TypeSymbol typeSymbol = null; if (type.IsInterface) { typeSymbol = new InterfaceSymbol(name, namespaceSymbol); } else if (MetadataHelpers.IsEnum(type)) { // NOTE: We don't care about the flags bit on imported enums // because this is only consumed by the generation logic. typeSymbol = new EnumerationSymbol(name, namespaceSymbol, /* flags */ false); if (MetadataHelpers.ShouldUseEnumNames(type)) { ((EnumerationSymbol)typeSymbol).SetNamedValues(); } else if (MetadataHelpers.ShouldUseEnumValues(type)) { ((EnumerationSymbol)typeSymbol).SetNumericValues(); } } else if (MetadataHelpers.IsDelegate(type)) { typeSymbol = new DelegateSymbol(name, namespaceSymbol); typeSymbol.SetTransformedName("Function"); } else { if (MetadataHelpers.ShouldTreatAsRecordType(type)) { typeSymbol = new RecordSymbol(name, namespaceSymbol); } else { typeSymbol = new ClassSymbol(name, namespaceSymbol); string mixinRoot; if (MetadataHelpers.ShouldGlobalizeMembers(type, out mixinRoot)) { ((ClassSymbol)typeSymbol).SetGlobalMethods(mixinRoot); } } } if (typeSymbol != null) { if (type.HasGenericParameters) { List <GenericParameterSymbol> genericArguments = new List <GenericParameterSymbol>(); foreach (GenericParameter genericParameter in type.GenericParameters) { GenericParameterSymbol arg = new GenericParameterSymbol(genericParameter.Position, genericParameter.Name, /* typeArgument */ true, _symbols.GlobalNamespace); genericArguments.Add(arg); } typeSymbol.AddGenericParameters(genericArguments); } typeSymbol.SetImported(assemblyScriptName); typeSymbol.SetMetadataToken(type, inScriptCoreAssembly); bool ignoreNamespace = MetadataHelpers.ShouldIgnoreNamespace(type); if (ignoreNamespace) { typeSymbol.SetIgnoreNamespace(); } typeSymbol.SetPublic(); if (String.IsNullOrEmpty(scriptNamespace) == false) { typeSymbol.ScriptNamespace = scriptNamespace; } if (String.IsNullOrEmpty(scriptName) == false) { typeSymbol.SetTransformedName(scriptName); } namespaceSymbol.AddType(typeSymbol); _importedTypes.Add(typeSymbol); } }