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