private static void GenerateInterfaceRegistrationScript(ScriptGenerator generator,
InterfaceSymbol interfaceSymbol)
{
ScriptTextWriter writer = generator.Writer;
writer.Write($"{DSharpStringResources.ScriptExportMember("defineInterface")}(");
writer.Write(interfaceSymbol.FullGeneratedName);
if (interfaceSymbol.Interfaces != null)
{
writer.Write(", [");
bool first = true;
foreach (InterfaceSymbol inheritedInterface in interfaceSymbol.Interfaces)
{
if (!first)
{
writer.Write(", ");
}
writer.Write(inheritedInterface.FullGeneratedName);
first = false;
}
writer.Write("]");
}
writer.Write(")");
}
private void ImportInterfaces(InterfaceSymbol interfaceSymbol)
{
TypeDefinition type = (TypeDefinition)interfaceSymbol.MetadataReference;
ICollection <InterfaceSymbol> interfaces = GetInterfaceSymbols(type.Interfaces);
interfaceSymbol.SetInheritance(interfaces);
}
private static void GenerateInterface(ScriptGenerator generator, InterfaceSymbol interfaceSymbol)
{
ScriptTextWriter writer = generator.Writer;
string interfaceName = interfaceSymbol.FullGeneratedName;
writer.Write("function ");
writer.Write(interfaceName);
writer.WriteLine("() { }");
}
private static void GenerateInterfaceComment(ScriptTextWriter writer, InterfaceSymbol interfaceSymbol)
{
writer.WriteNewLine();
writer.Indent++;
GenerateSummaryComment(writer, interfaceSymbol);
writer.Indent--;
}
protected virtual InterfaceSymbol VisitInterfaceSymbol(InterfaceSymbol interfaceSymbol)
{
foreach (var extendedInterfaceSymbol in interfaceSymbol?.Interfaces ?? Enumerable.Empty <InterfaceSymbol>())
{
Visit(extendedInterfaceSymbol);
}
return(interfaceSymbol);
}
private void BindInterfaceDeclaration(InterfaceTypeSyntax declaration)
{
Func <TypeSymbol, IEnumerable <MethodDeclarationSymbol> > lazyMemberSymbols = cd =>
{
var memberSymbols = new List <MethodDeclarationSymbol>();
foreach (var memberSyntax in declaration.Methods)
{
memberSymbols.Add(BindMethodDeclaration(memberSyntax, cd));
}
return(memberSymbols);
};
var symbol = new InterfaceSymbol(declaration, null, lazyMemberSymbols);
_bindingResult.AddSymbol(declaration, symbol);
_symbolSet.AddGlobal(symbol);
}
private BoundInterfaceType BindInterfaceDeclaration(InterfaceTypeSyntax declaration, Symbol parent)
{
var interfaceSymbol = new InterfaceSymbol(declaration, parent);
AddSymbol(interfaceSymbol, declaration.Name.SourceRange);
var methods = new List <BoundFunction>();
var interfaceBinder = new Binder(_sharedBinderState, this);
foreach (var memberSyntax in declaration.Methods)
{
methods.Add(interfaceBinder.Bind(memberSyntax, x => interfaceBinder.BindFunctionDeclaration(x, interfaceSymbol)));
}
foreach (var member in interfaceBinder.LocalSymbols.Values.SelectMany(x => x))
{
interfaceSymbol.AddMember(member);
}
return(new BoundInterfaceType(interfaceSymbol, methods.ToImmutableArray()));
}
public BoundInterfaceType(InterfaceSymbol interfaceSymbol, ImmutableArray <BoundFunction> methods)
: base(BoundNodeKind.InterfaceType, interfaceSymbol)
{
InterfaceSymbol = interfaceSymbol;
Methods = methods;
}
private static void GenerateInterface(ScriptGenerator generator, InterfaceSymbol interfaceSymbol)
{
ScriptTextWriter writer = generator.Writer;
string interfaceName = interfaceSymbol.FullGeneratedName;
if (interfaceSymbol.Namespace.Length == 0)
{
writer.Write("window.");
}
writer.Write(interfaceName);
writer.WriteTrimmed(" = ");
writer.Write("function()");
writer.WriteTrimmed(" { ");
if (generator.Options.EnableDocComments)
{
DocCommentGenerator.GenerateComment(generator, interfaceSymbol);
}
writer.Write("};");
writer.WriteNewLine();
if (generator.Options.DebugFlavor)
{
writer.Write(interfaceName);
writer.Write(".prototype = {");
writer.WriteLine();
writer.Indent++;
bool firstMember = true;
foreach (MemberSymbol member in interfaceSymbol.Members)
{
if (firstMember == false)
{
writer.Write(",");
writer.WriteLine();
}
if (member.Type == SymbolType.Property)
{
writer.Write("get_");
writer.Write(member.GeneratedName);
writer.WriteTrimmed(" : ");
writer.Write("null");
if (((PropertySymbol)member).IsReadOnly == false)
{
writer.Write(",");
writer.WriteLine();
writer.Write("set_");
writer.Write(member.GeneratedName);
writer.WriteTrimmed(" : ");
writer.Write("null");
}
}
else if (member.Type == SymbolType.Event)
{
writer.Write("add_");
writer.Write(member.GeneratedName);
writer.WriteTrimmed(" : ");
writer.Write("null,");
writer.WriteLine();
writer.Write("remove_");
writer.Write(member.GeneratedName);
writer.WriteTrimmed(" : ");
writer.Write("null");
}
else
{
writer.Write(member.GeneratedName);
writer.WriteTrimmed(" : ");
writer.Write("null");
}
firstMember = false;
}
writer.Indent--;
writer.WriteLine();
writer.Write("}");
writer.WriteSignificantNewLine();
}
writer.Write(interfaceName);
writer.Write(".registerInterface('");
writer.Write(interfaceName);
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);
}
}
private static void GenerateInterfaceRegistrationScript(ScriptGenerator generator, InterfaceSymbol interfaceSymbol)
{
ScriptTextWriter writer = generator.Writer;
writer.Write("ss.defineInterface(");
writer.Write(interfaceSymbol.FullGeneratedName);
if (interfaceSymbol.Interfaces != null)
{
writer.Write(", [");
bool first = true;
foreach (InterfaceSymbol inheritedInterface in interfaceSymbol.Interfaces)
{
if (!first)
{
writer.Write(", ");
}
writer.Write(inheritedInterface.FullGeneratedName);
first = false;
}
writer.Write("]");
}
writer.Write(")");
}
