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