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