public void InitItems(IEmitter emitter)
{
Logger.LogTrace("Initializing items for H5 types...");
this.Emitter = emitter;
byType = new Dictionary <IType, H5Type>();
foreach (var item in this)
{
var type = item.Value;
var key = H5Types.GetTypeDefinitionKey(type.TypeDefinition);
type.Emitter = emitter;
type.Type = ReflectionHelper.ParseReflectionName(key).Resolve(emitter.Resolver.Resolver.TypeResolveContext);
type.TypeInfo = emitter.Types.FirstOrDefault(t => t.Key == key);
if (type.TypeInfo != null && emitter.TypeInfoDefinitions.ContainsKey(type.TypeInfo.Key))
{
var typeInfo = this.Emitter.TypeInfoDefinitions[type.Key];
type.TypeInfo.Module = typeInfo.Module;
type.TypeInfo.FileName = typeInfo.FileName;
type.TypeInfo.Dependencies = typeInfo.Dependencies;
}
}
Logger.LogTrace("Initializing items for H5 types done");
}
public static string ToJavascriptName(AstType astType, IEmitter emitter)
{
string name = null;
var primitive = astType as PrimitiveType;
name = XmlToJsDoc.GetPrimitivie(primitive);
if (name != null)
{
return(name);
}
if (astType is ComposedType composedType && composedType.ArraySpecifiers != null && composedType.ArraySpecifiers.Count > 0)
{
return(JS.Types.ARRAY + ".<" + H5Types.ToTypeScriptName(composedType.BaseType, emitter) + ">");
}
if (astType is SimpleType simpleType && simpleType.Identifier == "dynamic")
{
return("object");
}
var resolveResult = emitter.Resolver.ResolveNode(astType);
return(XmlToJsDoc.ToJavascriptName(resolveResult.Type, emitter));
}
public static string GetParentNames(IEmitter emitter, TypeDefinition typeDef)
{
List <string> names = new List <string>();
while (typeDef.DeclaringType != null)
{
names.Add(H5Types.ToJsName(typeDef.DeclaringType, emitter, true, true));
typeDef = typeDef.DeclaringType;
}
names.Reverse();
return(names.Join("."));
}
public static string GetFunctionName(NamedFunctionMode mode, IMember member, IEmitter emitter, bool isSetter = false)
{
var overloads = OverloadsCollection.Create(emitter, member, isSetter);
string name = null;
switch (mode)
{
case NamedFunctionMode.None:
break;
case NamedFunctionMode.Name:
name = overloads.GetOverloadName(false, null, true);
break;
case NamedFunctionMode.FullName:
var td = member.DeclaringTypeDefinition;
name = td != null?H5Types.ToJsName(td, emitter, true) : "";
name = name.Replace(".", "_");
name += "_" + overloads.GetOverloadName(false, null, true);
break;
case NamedFunctionMode.ClassName:
var t = member.DeclaringType;
name = H5Types.ToJsName(t, emitter, true, true);
name = name.Replace(".", "_");
name += "_" + overloads.GetOverloadName(false, null, true);
break;
default:
throw new ArgumentOutOfRangeException();
}
if (name != null)
{
if (member is IProperty)
{
name = name + "_" + (isSetter ? "set" : "get");
}
else if (member is IEvent)
{
name = name + "_" + (isSetter ? "remove" : "add");
}
}
return(name);
}
public static string GetParentNames(IEmitter emitter, IType type)
{
List <string> names = new List <string>();
while (type.DeclaringType != null)
{
var name = H5Types.ConvertName(H5Types.ToJsName(type.DeclaringType, emitter, true, true));
if (type.DeclaringType.TypeArguments.Count > 0)
{
name += Helpers.PrefixDollar(type.TypeArguments.Count);
}
names.Add(name);
type = type.DeclaringType;
}
names.Reverse();
return(names.Join("."));
}
public static string GetInterfaceMemberName(IEmitter emitter, IMember interfaceMember, string name, string prefix, bool withoutTypeParams = false, bool isSetter = false, bool excludeTypeOnly = false)
{
var interfaceMemberName = name ?? OverloadsCollection.Create(emitter, interfaceMember, isSetter).GetOverloadName(true, prefix);
var interfaceName = H5Types.ToJsName(interfaceMember.DeclaringType, emitter, false, false, true, withoutTypeParams, excludeTypeOnly: excludeTypeOnly);
if (interfaceName.StartsWith("\""))
{
if (interfaceName.EndsWith(")"))
{
return(interfaceName + " + \"" + JS.Vars.D + interfaceMemberName + "\"");
}
if (interfaceName.EndsWith("\""))
{
interfaceName = interfaceName.Substring(0, interfaceName.Length - 1);
}
return(interfaceName + JS.Vars.D + interfaceMemberName + "\"");
}
return(interfaceName + (interfaceName.EndsWith(JS.Vars.D.ToString()) ? "" : JS.Vars.D.ToString()) + interfaceMemberName);
}
private static bool IsAcceptableTarget(NameSemantic semantic, ConventionTarget target, ITypeDefinition typeDef)
{
bool acceptable = true;
switch (target)
{
case ConventionTarget.Class:
acceptable = typeDef.Kind == TypeKind.Class;
break;
case ConventionTarget.Struct:
acceptable = typeDef.Kind == TypeKind.Struct;
break;
case ConventionTarget.Enum:
acceptable = typeDef.Kind == TypeKind.Enum;
break;
case ConventionTarget.Interface:
acceptable = typeDef.Kind == TypeKind.Interface;
break;
case ConventionTarget.Delegate:
acceptable = typeDef.Kind == TypeKind.Delegate;
break;
case ConventionTarget.ObjectLiteral:
acceptable = semantic.IsObjectLiteral || typeDef.GetAttribute(new FullTypeName("H5.ObjectLiteralAttribute"), false) != null;
break;
case ConventionTarget.Anonymous:
acceptable = typeDef.Kind == TypeKind.Anonymous;
break;
case ConventionTarget.External:
string externalAttr = "H5.ExternalAttribute";
var has =
typeDef.Attributes.Any(
attr =>
attr.Constructor != null &&
attr.Constructor.DeclaringType.FullName == externalAttr);
if (!has && typeDef.DeclaringTypeDefinition != null)
{
has =
typeDef.DeclaringTypeDefinition.Attributes.Any(
attr =>
attr.Constructor != null &&
attr.Constructor.DeclaringType.FullName == externalAttr);
}
if (!has)
{
has = H5Types.IsTypeFromH5Core(typeDef.FullName) ||
typeDef.ParentAssembly.AssemblyAttributes.Any(
attr =>
attr.Constructor != null &&
attr.Constructor.DeclaringType.FullName == externalAttr);
}
acceptable = has;
break;
default:
break;
}
return(acceptable);
}
public static string ToJavascriptName(IType type, IEmitter emitter)
{
if (type.Kind == TypeKind.Delegate)
{
var delegateName = H5Types.ConvertName(type.FullName);
if (!emitter.JsDoc.Callbacks.Contains(delegateName))
{
var method = type.GetDelegateInvokeMethod();
JsDocComment comment = new JsDocComment();
var parameters = method.Parameters;
if (parameters != null && parameters.Count > 0)
{
foreach (var param in parameters)
{
var jsParam = new JsDocParam();
jsParam.Name = param.Name;
jsParam.Type = XmlToJsDoc.ToJavascriptName(param.Type, emitter);
comment.Parameters.Add(jsParam);
}
}
comment.Returns.Add(new JsDocParam
{
Type = XmlToJsDoc.ToJavascriptName(method.ReturnType, emitter)
});
comment.Callback = delegateName;
comment.MemberOf = type.Namespace;
if (!emitter.JsDoc.Namespaces.Contains(type.Namespace))
{
emitter.JsDoc.Namespaces.Add(type.Namespace);
comment.Namespace = type.Namespace;
}
emitter.JsDoc.Callbacks.Add(delegateName);
emitter.WriteIndented(comment.ToString() + newLine + newLine, 0);
}
return(delegateName);
}
if (type.IsKnownType(KnownTypeCode.String))
{
return("string");
}
if (type.IsKnownType(KnownTypeCode.Boolean))
{
return("boolean");
}
if (type.IsKnownType(KnownTypeCode.Void))
{
return("void");
}
if (type.IsKnownType(KnownTypeCode.Byte) ||
type.IsKnownType(KnownTypeCode.Char) ||
type.IsKnownType(KnownTypeCode.Double) ||
type.IsKnownType(KnownTypeCode.Int16) ||
type.IsKnownType(KnownTypeCode.Int32) ||
type.IsKnownType(KnownTypeCode.SByte) ||
type.IsKnownType(KnownTypeCode.Single) ||
type.IsKnownType(KnownTypeCode.UInt16) ||
type.IsKnownType(KnownTypeCode.UInt32))
{
return("number");
}
if (type.Kind == TypeKind.Array)
{
ICSharpCode.NRefactory.TypeSystem.ArrayType arrayType = (ICSharpCode.NRefactory.TypeSystem.ArrayType)type;
return(JS.Types.ARRAY + ".<" + XmlToJsDoc.ToJavascriptName(arrayType.ElementType, emitter) + ">");
}
if (type.Kind == TypeKind.Dynamic)
{
return("object");
}
if (type.Kind == TypeKind.Enum && type.DeclaringType != null)
{
return("number");
}
if (NullableType.IsNullable(type))
{
return("?" + XmlToJsDoc.ToJavascriptName(NullableType.GetUnderlyingType(type), emitter));
}
H5Type h5Type = emitter.H5Types.Get(type, true);
//string name = H5Types.ConvertName(type.FullName);
var name = type.Namespace;
var hasTypeDef = h5Type != null && h5Type.TypeDefinition != null;
bool isNested = false;
if (hasTypeDef)
{
var typeDef = h5Type.TypeDefinition;
if (typeDef.IsNested)
{
name = (string.IsNullOrEmpty(name) ? "" : (name + ".")) + H5Types.GetParentNames(emitter, typeDef);
isNested = true;
}
name = (string.IsNullOrEmpty(name) ? "" : (name + ".")) + H5Types.ConvertName(typeDef.Name);
}
else
{
if (type.DeclaringType != null)
{
name = (string.IsNullOrEmpty(name) ? "" : (name + ".")) + H5Types.GetParentNames(emitter, type);
if (type.DeclaringType.TypeArguments.Count > 0)
{
name += Helpers.PrefixDollar(type.TypeArguments.Count);
}
isNested = true;
}
name = (string.IsNullOrEmpty(name) ? "" : (name + ".")) + H5Types.ConvertName(type.Name);
}
bool isCustomName = false;
if (h5Type != null)
{
name = H5Types.AddModule(name, h5Type, false, isNested, out isCustomName);
}
if (!hasTypeDef && !isCustomName && type.TypeArguments.Count > 0)
{
name += Helpers.PrefixDollar(type.TypeArguments.Count);
}
return(name);
}
public static string ToJsName(IType type, IEmitter emitter, bool asDefinition = false, bool excludens = false, bool isAlias = false, bool skipMethodTypeParam = false, bool removeScope = true, bool nomodule = false, bool ignoreLiteralName = true, bool ignoreVirtual = false, bool excludeTypeOnly = false)
{
var itypeDef = type.GetDefinition();
H5Type h5Type = emitter.H5Types.Get(type, true);
if (itypeDef != null)
{
string globalTarget = H5Types.GetGlobalTarget(itypeDef, null, removeScope);
if (globalTarget != null)
{
if (h5Type != null && !nomodule)
{
bool customName;
globalTarget = H5Types.AddModule(globalTarget, h5Type, excludens, false, out customName);
}
return(globalTarget);
}
}
if (itypeDef != null && itypeDef.Attributes.Any(a => a.AttributeType.FullName == "H5.NonScriptableAttribute"))
{
throw new EmitterException(emitter.Translator.EmitNode, "Type " + type.FullName + " is marked as not usable from script");
}
if (type.Kind == TypeKind.Array)
{
if (type is ArrayType arrayType && arrayType.ElementType != null)
{
string typedArrayName;
if (emitter.AssemblyInfo.UseTypedArrays && (typedArrayName = Helpers.GetTypedArrayName(arrayType.ElementType)) != null)
{
return(typedArrayName);
}
var elementAlias = H5Types.ToJsName(arrayType.ElementType, emitter, asDefinition, excludens, isAlias, skipMethodTypeParam, excludeTypeOnly: excludeTypeOnly);
if (isAlias)
{
return($"{elementAlias}$Array{(arrayType.Dimensions > 1 ? "$" + arrayType.Dimensions : "")}");
}
if (arrayType.Dimensions > 1)
{
return(string.Format(JS.Types.System.Array.TYPE + "({0}, {1})", elementAlias, arrayType.Dimensions));
}
return(string.Format(JS.Types.System.Array.TYPE + "({0})", elementAlias));
}
return(JS.Types.ARRAY);
}
if (type.Kind == TypeKind.Delegate)
{
return(JS.Types.FUNCTION);
}
if (type.Kind == TypeKind.Dynamic)
{
return(JS.Types.System.Object.NAME);
}
if (type is ByReferenceType)
{
return(H5Types.ToJsName(((ByReferenceType)type).ElementType, emitter, asDefinition, excludens, isAlias, skipMethodTypeParam, excludeTypeOnly: excludeTypeOnly));
}
if (ignoreLiteralName)
{
var isObjectLiteral = itypeDef != null && emitter.Validator.IsObjectLiteral(itypeDef);
var isPlainMode = isObjectLiteral && emitter.Validator.GetObjectCreateMode(emitter.GetTypeDefinition(type)) == 0;
if (isPlainMode)
{
return("System.Object");
}
}
if (type.Kind == TypeKind.Anonymous)
{
if (type is AnonymousType at && emitter.AnonymousTypes.ContainsKey(at))
{
return(emitter.AnonymousTypes[at].Name);
}
else
{
return(JS.Types.System.Object.NAME);
}
}
public static string DelegateToTemplate(string tpl, IMethod method, IEmitter emitter)
{
bool addThis = !method.IsStatic;
StringBuilder sb = new StringBuilder(tpl);
sb.Append("(");
bool comma = false;
if (addThis)
{
sb.Append("{this}");
comma = true;
}
if (!IsIgnoreGeneric(method, emitter) && method.TypeArguments.Count > 0)
{
foreach (var typeParameter in method.TypeArguments)
{
if (comma)
{
sb.Append(", ");
}
if (typeParameter.Kind == TypeKind.TypeParameter)
{
sb.Append("{");
sb.Append(typeParameter.Name);
sb.Append("}");
}
else
{
sb.Append(H5Types.ToJsName(typeParameter, emitter));
}
comma = true;
}
}
foreach (var parameter in method.Parameters)
{
if (comma)
{
sb.Append(", ");
}
sb.Append("{");
if (parameter.IsParams &&
method.Attributes.Any(a => a.AttributeType.FullName == "H5.ExpandParamsAttribute"))
{
sb.Append("*");
}
sb.Append(parameter.Name);
sb.Append("}");
comma = true;
}
sb.Append(")");
return(sb.ToString());
}
