private TypeSymbol CreateGenericTypeCore(TypeSymbol templateType, IList <TypeSymbol> typeArguments)
{
if (templateType.Type == SymbolType.Class)
{
ClassSymbol genericClass = (ClassSymbol)templateType;
ClassSymbol instanceClass = new ClassSymbol(genericClass.Name, (NamespaceSymbol)genericClass.Parent);
instanceClass.SetInheritance(genericClass.BaseClass, genericClass.Interfaces);
instanceClass.SetImported(genericClass.Dependency);
if (genericClass.IgnoreNamespace)
{
instanceClass.SetIgnoreNamespace();
}
instanceClass.ScriptNamespace = genericClass.ScriptNamespace;
if (genericClass.IsTransformed)
{
instanceClass.SetTransformedName(genericClass.GeneratedName);
}
else if (genericClass.IsTransformAllowed == false)
{
instanceClass.DisableNameTransformation();
}
if (genericClass.IsArray)
{
instanceClass.SetArray();
}
instanceClass.AddGenericParameters(genericClass.GenericParameters);
instanceClass.AddGenericArguments(genericClass, typeArguments);
CreateGenericTypeMembers(genericClass, instanceClass, typeArguments);
return(instanceClass);
}
else if (templateType.Type == SymbolType.Interface)
{
InterfaceSymbol genericInterface = (InterfaceSymbol)templateType;
InterfaceSymbol instanceInterface = new InterfaceSymbol(genericInterface.Name, (NamespaceSymbol)genericInterface.Parent);
instanceInterface.SetImported(genericInterface.Dependency);
if (genericInterface.IgnoreNamespace)
{
instanceInterface.SetIgnoreNamespace();
}
if (genericInterface.IsTransformed)
{
instanceInterface.SetTransformedName(genericInterface.GeneratedName);
}
else if (genericInterface.IsTransformAllowed == false)
{
instanceInterface.DisableNameTransformation();
}
instanceInterface.AddGenericParameters(genericInterface.GenericParameters);
instanceInterface.AddGenericArguments(genericInterface, typeArguments);
CreateGenericTypeMembers(genericInterface, instanceInterface, typeArguments);
return(instanceInterface);
}
else if (templateType.Type == SymbolType.Delegate)
{
DelegateSymbol genericDelegate = (DelegateSymbol)templateType;
DelegateSymbol instanceDelegate = new DelegateSymbol(genericDelegate.Name, (NamespaceSymbol)genericDelegate.Parent);
instanceDelegate.AddGenericParameters(genericDelegate.GenericParameters);
instanceDelegate.AddGenericArguments(genericDelegate, typeArguments);
CreateGenericTypeMembers(genericDelegate, instanceDelegate, typeArguments);
return(instanceDelegate);
}
return(null);
}
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 TypeSymbol CreateGenericTypeCore(TypeSymbol templateType, IList<TypeSymbol> typeArguments)
{
if (templateType.Type == SymbolType.Class) {
ClassSymbol genericClass = (ClassSymbol)templateType;
ClassSymbol instanceClass = new ClassSymbol(genericClass.Name, (NamespaceSymbol)genericClass.Parent);
instanceClass.SetInheritance(genericClass.BaseClass, genericClass.Interfaces);
instanceClass.SetImported(genericClass.Dependency);
if (genericClass.IgnoreNamespace) {
instanceClass.SetIgnoreNamespace();
}
instanceClass.ScriptNamespace = genericClass.ScriptNamespace;
if (genericClass.IsTransformed) {
instanceClass.SetTransformedName(genericClass.GeneratedName);
}
else if (genericClass.IsTransformAllowed == false) {
instanceClass.DisableNameTransformation();
}
if (genericClass.IsArray) {
instanceClass.SetArray();
}
instanceClass.AddGenericParameters(genericClass.GenericParameters);
instanceClass.AddGenericArguments(genericClass, typeArguments);
CreateGenericTypeMembers(genericClass, instanceClass, typeArguments);
return instanceClass;
}
else if (templateType.Type == SymbolType.Interface) {
InterfaceSymbol genericInterface = (InterfaceSymbol)templateType;
InterfaceSymbol instanceInterface = new InterfaceSymbol(genericInterface.Name, (NamespaceSymbol)genericInterface.Parent);
instanceInterface.SetImported(genericInterface.Dependency);
if (genericInterface.IgnoreNamespace) {
instanceInterface.SetIgnoreNamespace();
}
if (genericInterface.IsTransformed) {
instanceInterface.SetTransformedName(genericInterface.GeneratedName);
}
else if (genericInterface.IsTransformAllowed == false) {
instanceInterface.DisableNameTransformation();
}
instanceInterface.AddGenericParameters(genericInterface.GenericParameters);
instanceInterface.AddGenericArguments(genericInterface, typeArguments);
CreateGenericTypeMembers(genericInterface, instanceInterface, typeArguments);
return instanceInterface;
}
else if (templateType.Type == SymbolType.Delegate) {
DelegateSymbol genericDelegate = (DelegateSymbol)templateType;
DelegateSymbol instanceDelegate = new DelegateSymbol(genericDelegate.Name, (NamespaceSymbol)genericDelegate.Parent);
instanceDelegate.AddGenericParameters(genericDelegate.GenericParameters);
instanceDelegate.AddGenericArguments(genericDelegate, typeArguments);
CreateGenericTypeMembers(genericDelegate, instanceDelegate, typeArguments);
return instanceDelegate;
}
return null;
}
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);
}
}
private static void GenerateDelegate(ScriptGenerator generator, DelegateSymbol delegateSymbol) {
// No-op
// There is currently nothing to generate for a particular delegate type
}
private void DumpDelegate(DelegateSymbol delegateSymbol)
{
}
private void DumpDelegate(DelegateSymbol delegateSymbol)
{
}