private static void GenerateInterfaceComment(ScriptTextWriter writer, InterfaceSymbol interfaceSymbol) {
writer.WriteNewLine();
writer.Indent++;
GenerateSummaryComment(writer, interfaceSymbol);
writer.Indent--;
}
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 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 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 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 DumpInterface(InterfaceSymbol interfaceSymbol)
{
}
private void DumpInterface(InterfaceSymbol interfaceSymbol)
{
}
