public override JsNode ExportMethod(IMethod me)
{
if (Sk.IsGlobalMethod(me))
{
return(CreateGlobalMemberConverter().ExportMethod(me));
}
var node = base.ExportMethod(me);
if (node == null)
{
return(node);
}
if (!node.Is(JsNodeType.Function))
{
return(node);
}
var func = (JsFunction)node;
func.Name = null;
var ce = me.GetDeclaringTypeDefinition();
var member = ExportTypePrefix(ce, me.IsStatic);
member = member.Member(SkJs.GetEntityJsName(me));
if (LongFunctionNames)
{
func.Name = SkJs.GetLongFunctionName(me);
}
var st = member.Assign(func).Statement();
return(st);
}
protected IField GenerateBackingField(IProperty pe)
{
var field = GenerateFakeField(pe);
field.Name = "_" + SkJs.GetEntityJsName(pe);
return(field);
}
public JsNode VisitConstantResolveResult(ConstantResolveResult res)
{
var nodes = res.GetNodes();
if (res.Type is DefaultTypeParameter)
{
return(Js.Member("Default").Invoke(SkJs.EntityTypeRefToMember(res.Type)));
}
if (res.Type != null && res.Type.Kind == TypeKind.Enum)
{
var enumMembers = res.Type.GetFields();
var me = enumMembers.Where(t => (t.ConstantValue != null) && t.ConstantValue.Equals(res.ConstantValue)).FirstOrDefault();
if (me != null)
{
return(Visit(me.AccessSelf()));//.Access().Member(c.CreateTypeRef(en), defaultEnumMember);
}
//TODO:
//return Visit(JsTypeImporter.GetValueTypeInitializer(res.Type, Project));
}
//var nodes = res.GetNodes();
//if (nodes.IsNotNullOrEmpty())
//{
// var node = nodes[0];
// if (node != null && node is PrimitiveExpression)
// {
// var node2 = Visit(node); //use literal value instead
// return node2;
// }
//}
return(Js.Value(res.ConstantValue));
}
public JsNode VisitConstantResolveResult(ConstantResolveResult res)
{
if (res.Type is DefaultTypeParameter)
{
return(Js.Member("Default").Invoke(SkJs.EntityTypeRefToMember(res.Type)));
}
if (res.Type != null && res.Type.Kind == TypeKind.Enum)
{
var enumMembers = res.Type.GetFields();
var me = enumMembers.Where(t => (t.ConstantValue != null) && t.ConstantValue.Equals(res.ConstantValue)).FirstOrDefault();
if (me != null)
{
return(Visit(me.AccessSelf()));//.Access().Member(c.CreateTypeRef(en), defaultEnumMember);
}
//TODO:
//return Visit(JsTypeImporter.GetValueTypeInitializer(res.Type, Project));
}
var nodes = res.GetNodes();
if (nodes.IsNotNullOrEmpty())
{
if (nodes[0] != null)
{
bool isPrimitiveExpr = nodes[0] is PrimitiveExpression;
if (!isPrimitiveExpr)
{
return(Js.Value(res.ConstantValue, string.Format(" /* {0} */", nodes[0].ToString())));
}
}
}
return(Js.Value(res.ConstantValue));
}
public TsFunction Visit(IMethod me)
{
if (me is FakeMethod)
{
return(null);
}
TsFunction me2 = new TsFunction
{
Name = SkJs.GetEntityJsName(me),
IsStatic = me.IsStatic,
Parameters = me.Parameters.Select(Visit).ToList()
};
if (me.SymbolKind == SymbolKind.Constructor)
{
me2.Name = SkJs.GetEntityJsName(me);// "constructor";
//if (me2.Name.StartsWith("."))
//me2.IsConstructor = true;
}
else
{
me2.Type = Visit(me.ReturnType);
me2.TypeParameters = me.TypeParameters.Select(Visit).ToList();
}
return(me2);
}
private JsClrAttribute ExportAttribute(IEntity parent, IAttribute att)
{
var attCtor = att.Constructor;
var attType = att.AttributeType;
var target = GetAttributeTarget(parent, att);
var jsAtt = new JsClrAttribute
{
targetType = target.Key,
targetMemberName = target.Value,
typeName = SkJs.GetEntityJsName(attType),
ctorName = SkJs.GetEntityJsName(attCtor),
};
if (att.PositionalArguments.IsNotNullOrEmpty())
{
jsAtt.positionalArguments = new JsArray <object>();
var args = att.PositionalArguments.Select(exp => ImportAttributeValue(exp)).ToList();
jsAtt.positionalArguments.AddRange(args);
}
if (att.NamedArguments.IsNotNullOrEmpty())
{
jsAtt.namedArguments = new JsObject();
foreach (var arg in att.NamedArguments)
{
jsAtt.namedArguments[arg.Key.Name] = ImportAttributeValue(arg.Value);
}
}
return(jsAtt);
}
protected IField GenerateBackingField(IProperty pe)
{
var field = GenerateFakeField(pe);
// 这里容易冲突，因此前缀复杂一点好
field.Name = AutoPropertyPrefix + SkJs.GetEntityJsName(pe);
return(field);
}
protected virtual JsNode ExportPropertyInfo(IProperty pe)
{
var name = SkJs.GetEntityJsName(pe) + "$$";
var value = Js.String(pe.GetPropertyTypeRef().GetFullyQualifiedCLRName());
//CurrentType.GetDefinition(pe.IsStatic)[name] = value;
return(Js.JsonNameValue(name, value));
}
public override JsNode ExportConstructor(IMethod ctor)
{
var ctorName = SkJs.GetEntityJsName(ctor);
var func = base.ExportConstructor(ctor);
//CurrentType.definition[ctorName] = func;
return(Js.JsonNameValue(ctorName, (JsExpression)func));
//return func;
}
public JsNode VisitMemberResolveResult(MemberResolveResult res)
{
var me = res.Member;
JsNode node2;
bool enumValuesAsNames;
if (me == null) //TODO: dynamics
{
throw new NotImplementedException();
//var node3 = Js.Member(node.MemberName);
//if (node.Target != null)
// node3.PreviousMember = VisitExpression(node.Target);
//return node3;
}
else if (Sk.IsEntityFunctionProperty(res.Member, res))//(Entity)node.entity))
{
var pe = (IProperty)me;
var xxx = new CSharpInvocationResolveResult(res.TargetResult, pe.Getter, null);
node2 = Visit(xxx);
return(node2);
}
else if (me.IsEnumMember() && Sk.UseJsonEnums(me, out enumValuesAsNames))
{
var me2 = (IField)me;
if (enumValuesAsNames)
{
return(Js.String(SkJs.GetEntityJsName(me2)));
}
else
{
return(Js.Value(me2.ConstantValue));
}
}
//TODO: Support a way to override this (JsField.ConstantInlining=false)
else if (res.IsCompileTimeConstant && !me.IsEnumMember())
{
return(Js.Value(res.ConstantValue));
}
else
{
var node3 = SkJs.EntityToMember(me);
node2 = node3;
if (res.TargetResult != null && !me.IsStatic())
{
var instanceContext = VisitExpression(res.TargetResult);
if (node3.Name.IsNullOrEmpty()) //support Name=""
{
node2 = instanceContext;
}
else
{
node3.PreviousMember = instanceContext;
}
}
}
return(node2);
}
public virtual JsNode ExportConstructor(IMethod ctor)
{
var ctorName = SkJs.GetEntityJsName(ctor);
var func = new JsFunction {
Parameters = new List <string>()
};
func.Block = ExportConstructorBody(ctor);
ExportConstructorParameters(ctor, func);
return(func);
}
public override JsNode _VisitClass(ITypeDefinition ce)
{
var unit = new JsUnit {
Statements = new List <JsStatement>()
};
ExportTypeNamespace(unit, ce);
var members = GetMembersToExport(ce);
VisitToUnit(unit, members);
var baseCe = ce.GetBaseTypeDefinition();
if (baseCe != null && Sk.IsNativeType(baseCe) && !Sk.IsGlobalType(baseCe) && !Sk.OmitInheritance(ce))
{
unit.Statements.Add(Js.Member("$Inherit").Invoke(SkJs.EntityToMember(ce), SkJs.EntityToMember(baseCe)).Statement());
}
return(unit);
}
public JsNode VisitArrayCreateResolveResult(ArrayCreateResolveResult res)
{
var jsArrayType = SkJs.GetJsArrayType((ArrayType)res.Type);
JsExpression[] items = null;
JsExpression size = null;
if (res.InitializerElements.IsNotNullOrEmpty())
{
items = VisitExpressions(res.InitializerElements).ToArray();
}
else if (res.SizeArguments.IsNotNullOrEmpty())
{
size = VisitExpression(res.SizeArguments.Single());
}
return(Js.NewArray(jsArrayType, size, items));
}
void ProcessGenericMethodArgs()
{
GenericArgs = new List <GenericArg>();
if (Method != null && Method is SpecializedMethod && !Sk.IgnoreGenericMethodArguments(Method))
{
if (Method.IsConstructor)
{
var ce = Method.DeclaringType as ParameterizedType;
if (ce != null)
{
GenericArgs.AddRange(ce.TypeArguments.Select(t => new GenericArg {
JsExpression = SkJs.EntityTypeRefToMember(t, true), Arg = t
}).ToList());
}
}
else
{
var sme = (SpecializedMethod)Method;
var genericMethodArgs = sme.TypeArguments.Select(t => new GenericArg {
JsExpression = SkJs.EntityTypeRefToMember(t, true), Arg = t
}).ToList();
var i = 0;
foreach (var z in Method.TypeParameters)
{
if (i >= genericMethodArgs.Count)
{
continue;
}
genericMethodArgs[i].TypeParam = z;
i++;
}
GenericArgs.AddRange(genericMethodArgs);
}
var jsArgs = GenericArgs.Select(t => t.JsExpression).ToList();
if (Node2.Arguments == null)
{
Node2.Arguments = new List <JsExpression>(jsArgs);
}
else
{
Node2.Arguments.InsertRange(0, jsArgs);
}
}
}
public virtual JsNode ExportMethod(IMethod me)
{
var jma = Sk.GetJsMethodAttribute(me);
if (jma != null && jma.GlobalCode)
{
var block = ExportMethodBody(me);
return(new JsUnit {
Statements = block.Statements
});
}
var func = new JsFunction();
func.Parameters = ExportMethodParameters(me);
func.Name = SkJs.GetEntityJsName(me);
func.Block = ExportMethodBody(me);
func = ApplyYield(func);
return(func);
}
private void ProcessEnum()
{
if (Method.DeclaringType.FullName == "System.Enum")
{
// Enum.GetName
if (Method.Name == "ToString")
{
// 插对象
if (MethodAtt == null || !MethodAtt.InstanceImplementedAsExtension)
{
var ext = (JsMemberExpression)Node2.Member;
Node2.Arguments.Insert(0, ext.PreviousMember);
ext.PreviousMember = null;
}
// 插类型
var ctor = SkJs.EntityTypeRefToMember(Res.TargetResult.Type, false);
Node2.Arguments.Insert(0, Js.Invoke(new JsMemberExpression {
Name = "Typeof"
}, ctor as JsMemberExpression));
}
}
}
public override JsNode ExportMethod(IMethod me)
{
var node = base.ExportMethod(me);
if (node == null)
{
return(node);
}
if (!node.Is(JsNodeType.Function))
{
return(node);
}
var func = (JsFunction)node;
var funcName = func.Name;
func.Name = null;
if (LongFunctionNames)
{
func.Name = SkJs.GetLongFunctionName(me);
}
return(Js.JsonNameValue(funcName, func));
}
private KeyValuePair <string, string> GetAttributeTarget(IEntity parent, IAttribute att)
{
if (parent is ITypeDefinition)
{
return(new KeyValuePair <string, string>("type", null));
}
else if (parent.SymbolKind == SymbolKind.Property)
{
return(new KeyValuePair <string, string>("property", SkJs.GetEntityJsName(parent)));
}
else if (parent.SymbolKind == SymbolKind.Method)
{
var method = (IMethod)parent;
if (method.IsConstructor)
{
return(new KeyValuePair <string, string>("constructor", SkJs.GetEntityJsName(method)));
}
else
{
return(new KeyValuePair <string, string>("method", SkJs.GetEntityJsName(method)));
}
}
throw new NotImplementedException("GetAttributeTarget no implemented for member: " + parent);
}
public JsNode VisitTypeIsResolveResult(TypeIsResolveResult res)
{
if (Sk.OmitCasts(res.TargetType))
{
return(Js.True());
//var node2 = Visit(res.Input);
//return node2;
}
else if (Sk.NativeCasts(res.TargetType))
{
var typeFieldName = Sk.GetJsonTypeFieldName(res.TargetType.GetDefinitionOrArrayType());
if (typeFieldName != null && Sk.IsJsonMode(res.TargetType.GetDefinitionOrArrayType()))
{
return(Js.Parentheses(VisitExpression(res.Input).Or(Js.Json())).Member(typeFieldName).Equal(SkJs.EntityTypeRefToMember(res.TargetType)));
}
var node2 = VisitExpression(res.Input).InstanceOf(SkJs.EntityTypeRefToMember(res.TargetType));
return(node2);
}
else
{
var node2 = Js.Member("Is").Invoke(VisitExpression(res.Input), SkJs.EntityTypeRefToMember(res.TargetType));
return(node2);
}
}
public TsType Visit(ITypeDefinition ce)
{
var name = SkJs.GetEntityJsName(ce);
var ce2 = new TsType
{
Name = name, Kind = (ce.IsInterface() || ce.IsDelegate()) ? TsTypeKind.Interface : TsTypeKind.Class,
TypeParameters = ce.TypeParameters.Select(Visit).ToList()
};
if (name.Contains("."))
{
var pair = name.SplitAt(name.LastIndexOf("."), true);
ce2.Name = pair[1];
ce2.ModuleName = pair[0];
ce2.IsModuleExport = true;
}
if (ce.IsDelegate())
{
var func = Visit(ce.GetDelegateInvokeMethod());
//func.IsCallSignature = true;
func.Name = null;
ce2.Members.Add(func);
}
else
{
var members = TypeConverter.ClrConverter.GetMembersToExport(ce);
var members2 = members.Select(Visit).Where(t => t != null).ToList();
ce2.Members.AddRange(members2);
if (ce2.Kind == TsTypeKind.Class)
{
ce2.Members.OfType <TsFunction>().Where(t => !t.IsConstructor || !t.Type.IsNullOrVoid()).ForEach(t => t.Body = "return null;");
ce2.Members.OfType <TsFunction>().Where(t => t.IsConstructor).ForEach(t => t.Body = "");
}
}
return(ce2);
}
internal JsExpression InitializersToJson(IList <ResolveResult> initializerStatements, IType type)
{
//if (Sk.IsNativeArrayEnumerator(type.GetDefinition()))
//FIX for issue 325:
if (Sk.IsNativeArrayEnumerator(type.GetDefinition()) && (initializerStatements.IsEmpty() || initializerStatements[0] is CSharpInvocationResolveResult))
{
var items = initializerStatements.Cast <CSharpInvocationResolveResult>().Select(t => t.Arguments[0]).ToList();
var items2 = VisitExpressions(items);
var arr = Js.NewJsonArray(items2.ToArray());
return(arr);
}
else
{
var json = Js.Json();
foreach (var st in initializerStatements)
{
if (st is OperatorResolveResult)
{
var op = (OperatorResolveResult)st;
var mrr = (MemberResolveResult)op.Operands[0];
var name = SkJs.GetEntityJsName(mrr.Member);
var value = VisitExpression(op.Operands[1]);
var pair = Js.JsonNameValue(name, value);
if (mrr.TargetResult is MemberResolveResult) //happens when using object initializers to set inner properties, e.g. new Parent { Child = { Name="ggg" } }
{
var targetMrr = (MemberResolveResult)mrr.TargetResult;
var name2 = SkJs.GetEntityJsName(targetMrr.Member);
var innerJson = Js.Json();
innerJson.Add(pair);
pair = Js.JsonNameValue(name2, innerJson);
}
json.Add(pair);
}
else if (st is InvocationResolveResult)
{
var irr = (InvocationResolveResult)st;
var targetMrr = irr.TargetResult as MemberResolveResult;
if (targetMrr == null)
{
throw new CompilerException(st.GetFirstNode(), "Expected MemberResolveResult");
}
var name = SkJs.GetEntityJsName(targetMrr.Member);
if (irr.Arguments.Count != 1)
{
throw new CompilerException(st.GetFirstNode(), "Expected one argument, not " + name + " " + irr.Arguments.Count);
}
var value = VisitExpression(irr.Arguments[0]);
var jsonMember = json.NamesValues.NotNull().FirstOrDefault(t => t.Name.Name == name);
if (jsonMember == null)
{
json.Add(name, Js.NewJsonArray(value));
}
else
{
var array = jsonMember.Value as JsJsonArrayExpression;
if (array == null)
{
throw new CompilerException(st.GetFirstNode(), "json member value array not found " + name);
}
array.Items.Add(value);
}
}
else
{
throw new NotImplementedException();
}
}
//var inits2 = initializerStatements.Select(t => Visit(t)).ToList();
//var namesValues = inits2.Cast<JsBinaryExpression>().Select(t => Js.JsonNameValue(((JsMemberExpression)t.Left).Name, t.Right)).ToList();
//var json = Js.Json();
//json.NamesValues = namesValues;
return(json);
}
}
public JsNode VisitTypeOfResolveResult(TypeOfResolveResult res)
{
return(Js.Member("Typeof").Invoke(SkJs.EntityTypeRefToMember(res.ReferencedType)));
}
public JsNode VisitInvocationResolveResultAsCtor(CSharpInvocationResolveResult res)
{
if (res.Type.Kind == TypeKind.Delegate)
{
return(Visit(res.Arguments.Single()));
}
var me = (IMethod)res.Member;
var meAtt = Sk.GetJsMethodAttribute(me);
var ce = me.GetDeclaringTypeDefinition();
var att = ce == null ? null : ce.GetJsTypeAttribute();
if (att != null && att.Mode == JsMode.Json && (meAtt == null || meAtt.Name == null))
{
var jtfn = ce == null ? null : Sk.GetJsonTypeFieldName(ce);
var node2 = VisitInvocationResolveResult(res);
var json = Importer.InitializersToJson(res.InitializerStatements, res.Type);
if (jtfn != null)
{
var x = json as JsJsonObjectExpression;
if (x != null)
{
x.Add(jtfn, SkJs.EntityTypeRefToMember(res.Type));
}
}
return(json);
}
else
{
var invokeExp = (JsInvocationExpression)VisitInvocationResolveResult(res);
var newExp = new JsNewObjectExpression {
Invocation = invokeExp
};
JsExpression finalExp;
if (meAtt != null && meAtt.OmitNewOperator)
{
finalExp = invokeExp;
}
else
{
finalExp = newExp;
}
if (meAtt != null && meAtt.JsonInitializers)
{
var json = Importer.InitializersToJson(res.InitializerStatements, res.Type);
invokeExp.Arguments.Add(json);
}
else if (res.InitializerStatements.IsNotNullOrEmpty())
{
var func = Js.Function();
var inits2 = res.InitializerStatements.Select(t => Visit(t)).ToList();
//var init1 = res.InitializerStatements[0];
var target = AstNodeConverter.FindInitializedObjectResolveResult(res);// ((init1 as OperatorResolveResult).Operands[0] as MemberResolveResult).TargetResult as InitializedObjectResolveResult;
var varName = Importer.Initializers[target];
func.Add(Js.Var(varName, finalExp).Statement());
foreach (var init in inits2)
{
var exp = ((JsExpression)init);
func.Add(exp.Statement());
}
func.Add(Js.Return(Js.Member(varName)));
finalExp = Importer.WrapFunctionAndInvoke(res, func);
}
return(finalExp);
}
}
private TsTypeRef Visit(IType type)
{
if (type == null)
{
return new TsTypeRef {
Name = "void"
}
}
;
var typeDef = type.GetDefinition();
if (typeDef != null)
{
var ktc = typeDef.KnownTypeCode;
if (ktc != KnownTypeCode.None)
{
if (ktc == KnownTypeCode.Void)
{
return new TsTypeRef {
Name = "void"
}
}
;
else if (ktc == KnownTypeCode.Object)
{
return new TsTypeRef {
Name = "any"
}
}
;
else if (ktc == KnownTypeCode.String)
{
return new TsTypeRef {
Name = "string"
}
}
;
else if (ktc == KnownTypeCode.Boolean)
{
return new TsTypeRef {
Name = "boolean"
}
}
;
else if (ktc == KnownTypeCode.Int32 ||
ktc == KnownTypeCode.Int32 ||
ktc == KnownTypeCode.Int16 ||
ktc == KnownTypeCode.Int64 ||
ktc == KnownTypeCode.Double ||
ktc == KnownTypeCode.Single ||
ktc == KnownTypeCode.SByte ||
ktc == KnownTypeCode.Byte ||
ktc == KnownTypeCode.UInt16 ||
ktc == KnownTypeCode.UInt32 ||
ktc == KnownTypeCode.UInt64 ||
ktc == KnownTypeCode.Decimal
)
{
return new TsTypeRef {
Name = "number"
}
}
;
}
if (Sk.IsJsonMode(typeDef))
{
return new TsTypeRef {
Name = "Object"
}
}
;
if (type.Kind == TypeKind.Delegate && !Sk.IsJsExported(type.GetDefinition()))
{
var func = Visit(type.GetDelegateInvokeMethod());
func.Name = null;
func.IsCallSignature = true;
return(new TsTypeRef {
AnonymousCallSignature = func
});
}
}
var tr2 = new TsTypeRef {
Name = SkJs.GetEntityJsName(type)
};
tr2.GenericArguments = type.TypeArguments.Select(Visit).ToList();
if (tr2.Name == "Array" && tr2.GenericArguments.Count == 0)
{
tr2.GenericArguments.Add(new TsTypeRef {
Name = "any"
});
}
return(tr2);
}
public JsNode VisitMemberResolveResult(MemberResolveResult res)
{
var me = res.Member;
JsNode node2;
bool enumValuesAsNames;
if (me == null) //TODO: dynamics
{
throw new NotImplementedException();
//var node3 = Js.Member(node.MemberName);
//if (node.Target != null)
// node3.PreviousMember = VisitExpression(node.Target);
//return node3;
}
else if (Sk.IsEntityFunctionProperty(res.Member, res))//(Entity)node.entity))
{
var pe = (IProperty)me;
var xxx = new CSharpInvocationResolveResult(res.TargetResult, pe.Getter, null);
var fn = res.GetFirstNode();
qiucw.InvokeRR2Location.Add(xxx, new qiucw.InvocationLocation {
FileName = fn.GetFileName(), Line = fn.StartLocation.Line
});
{
node2 = Visit(xxx);
}
qiucw.InvokeRR2Location.Remove(xxx);
return(node2);
}
else if (me.IsEnumMember() && Sk.UseJsonEnums(me, out enumValuesAsNames))
{
var me2 = (IField)me;
if (enumValuesAsNames)
{
return(Js.String(SkJs.GetEntityJsName(me2)));
}
else
{
return(Js.Value(me2.ConstantValue));
}
}
//TODO: Support a way to override this (JsField.ConstantInlining=false)
else if (res.IsCompileTimeConstant && !me.IsEnumMember())
{
var nodes = res.GetNodes();
if (nodes.IsNotNullOrEmpty())
{
if (nodes[0] != null)
{
bool isPrimitiveExpr = nodes[0] is PrimitiveExpression;
if (!isPrimitiveExpr)
{
return(Js.Value(res.ConstantValue, string.Format(" /* {0} */", nodes[0].ToString())));
}
}
}
return(Js.Value(res.ConstantValue));
}
else
{
var node3 = SkJs.EntityToMember(me);
qiucw.CheckAddInvocation(res, node3.Name);
node2 = node3;
if (res.TargetResult != null && !me.IsStatic())
{
var instanceContext = VisitExpression(res.TargetResult);
if (node3.Name.IsNullOrEmpty()) //support Name=""
{
node2 = instanceContext;
}
else
{
node3.PreviousMember = instanceContext;
}
}
}
return(node2);
}
private JsNode VisitConversion(ResolveResult input, Conversion conversion, IType conversionType)
{
////TODO: HACK: https://github.com/icsharpcode/NRefactory/issues/183
//var isImplicit = res.Conversion.IsImplicit;
//if (!isImplicit && res.Conversion.IsExplicit && res.Conversion.Method != null && res.Conversion.Method.Name != null && res.Conversion.Method.Name.Contains("Implicit"))
// isImplicit = true;
if (conversion.IsMethodGroupConversion)
{
}
else if (conversion.IsUserDefined)
{
ITypeDefinition typeDef;
if (conversion.Method != null && conversion.Method.DeclaringType != null)
{
typeDef = conversion.Method.DeclaringType.GetDefinitionOrArrayType();
}
else
{
typeDef = conversionType.GetDefinitionOrArrayType();
}
var nativeOverloads = Sk.UseNativeOperatorOverloads(typeDef);
if (nativeOverloads)
{
return(Visit(input));
}
////TODO: Check if OmitCalls is found on conversion method, if so - return Visit(input);
//if (Sk.IsOmitCalls(conversion.Method))
//{
//}
var fake = conversion.Method.InvokeMethod(null, input);
var node2 = Visit(fake);
return(node2);
}
else if (conversion.IsTryCast || conversion.IsExplicit)
{
if (ForceIntegers && conversion.IsNumericConversion && IsInteger(conversionType))
{
return(ForceInteger(Visit(input)));
}
//Skip enum casts
if ((conversionType.Kind == TypeKind.Enum && IsInteger(input.Type)) || (input.Type.Kind == TypeKind.Enum && IsInteger(conversionType)))
{
return(Visit(input));
}
var omitCasts = Sk.OmitCasts(conversionType);
if (omitCasts)
{
return(Visit(input));
}
if (Sk.NativeCasts(conversionType))
{
var exp2 = VisitExpression(input);
var type2 = SkJs.EntityTypeRefToMember(conversionType);
if (conversion.IsTryCast)
{
var node2 = exp2.InstanceOf(type2).Conditional(exp2, Js.Null());
return(node2);
}
else
{
var node2 = Js.Conditional(exp2.InstanceOf(type2).Or(exp2.Equal(Js.Null())), exp2,
Js.Parentheses(Js.Function().Add(Js.ThrowNewError("InvalidCastException")).Invoke()));
//var node2 = Js.Parentheses(Js.Function().AddStatements(
//Js.If(exp2.InstanceOf(type2).Or(exp2.Equal(Js.Null())), Js.Return(exp2)),
//Js.ThrowNewError("InvalidCastException"))).Member("call").Invoke(Js.This());
return(node2);
}
}
else
{
var cast = conversion.IsTryCast ? "As" : "Cast";
var node2 = Js.Member(cast).Invoke(VisitExpression(input), SkJs.EntityTypeRefToMember(conversionType));
return(node2);
}
}
return(Visit(input));
}
public JsNode VisitTypeResolveResult(TypeResolveResult res)
{
return(SkJs.EntityTypeRefToMember(res.Type));
//throw new NotImplementedException();
}
public JsNode VisitMethodGroupResolveResult(MethodGroupResolveResult res)
{
var info = res.GetInfo();
IMethod me;
if (info != null && info.Conversion != null && info.Conversion.Method != null)
{
me = info.Conversion.Method;
}
else //happens when invoking a method with overloads, and a parameter is dynamic
{
var list = res.Methods.ToList();
if (list.Count == 0)
{
throw new Exception("Method group not resolved to any method");
}
else if (list.Count == 1)
{
me = list[0];
}
else
{
me = list[0];
}
//TODO: verify all methods has the same js name
}
var isExtensionMethodStyle = me.IsExtensionMethod && !(res.TargetResult is TypeResolveResult) && info != null && info.Conversion != null && info.Conversion.DelegateCapturesFirstArgument;//TODO: IsExtensionMethodStyle(new CsInvocationExpression { entity = me, expression = node });
JsExpression firstPrm = null;
if (isExtensionMethodStyle)
{
firstPrm = (JsExpression)Visit(res.TargetResult);
}
var node2 = SkJs.EntityToMember(me);
JsExpression node3;
JsExpression instanceContext = null;
if (me.IsStatic || res.TargetResult == null) //getting ThisResolveResult even on static methods, getting TargetResult=null when MethodGroupResolveResult when using delegates
{
node3 = node2;
}
else
{
instanceContext = VisitExpression(res.TargetResult);
node3 = instanceContext.Member(node2);
}
if (info != null && (instanceContext != null || firstPrm != null))
{
var conv = info.Conversion;
if (info.ConversionTargetType != null && !UseNativeFunctions(info.ConversionTargetType))//delegate type
{
var parentMethod = info.Nodes.FirstOrDefault().GetCurrentMethod();
if (parentMethod == null || !Sk.ForceDelegatesAsNativeFunctions(parentMethod))
{
if (parentMethod == null)
{
Log.Warn(info.Nodes.FirstOrDefault(), "GetParentMethod() returned null");
}
var func = (JsExpression)node2;
if (instanceContext != null)
{
node3 = CreateJsDelegate(instanceContext, func);
}
else if (firstPrm != null)
{
node3 = CreateJsExtensionDelegate(firstPrm, func);
}
}
}
}
return(node3);
}
private JsInvocationExpression ExportDefault(IType type)
{
return(Js.Member("Default").Invoke(SkJs.EntityTypeRefToMember(type)));
}
public JsNode VisitMethodGroupResolveResult(MethodGroupResolveResult res)
{
var info = res.GetInfo();
IMethod me;
if (info != null && info.Conversion != null && info.Conversion.Method != null)
{
me = info.Conversion.Method;
}
else //happens when invoking a method with overloads, and a parameter is dynamic
{
var list = res.Methods.ToList();
if (list.Count == 0)
{
throw new Exception("Method group not resolved to any method");
}
else if (list.Count == 1)
{
me = list[0];
}
else
{
me = list[0];
}
//TODO: verify all methods has the same js name
}
var isExtensionMethodStyle = me.IsExtensionMethod && !(res.TargetResult is TypeResolveResult) && info != null && info.Conversion != null && info.Conversion.DelegateCapturesFirstArgument;//TODO: IsExtensionMethodStyle(new CsInvocationExpression { entity = me, expression = node });
JsExpression firstPrm = null;
if (isExtensionMethodStyle)
{
firstPrm = (JsExpression)Visit(res.TargetResult);
}
var node2 = SkJs.EntityToMember(me);
JsExpression node3;
JsExpression instanceContext = null;
if (me.IsStatic || res.TargetResult == null) //getting ThisResolveResult even on static methods, getting TargetResult=null when MethodGroupResolveResult when using delegates
{
node3 = node2;
}
else
{
instanceContext = VisitExpression(res.TargetResult);
node3 = instanceContext.Member(node2);
}
if (info != null && (instanceContext != null || firstPrm != null))
{
if (info.ConversionTargetType != null && !UseNativeFunctions(info.ConversionTargetType))//delegate type
{
var parentMethod = info.Nodes.FirstOrDefault().GetCurrentMethod();
if (parentMethod == null || !Sk.ForceDelegatesAsNativeFunctions(parentMethod))
{
if (parentMethod == null)
{
Log.Warn(info.Nodes.FirstOrDefault(), "GetParentMethod() returned null");
}
var func = (JsExpression)node2;
if (instanceContext != null)
{
node3 = CreateJsDelegate(instanceContext, func);
}
else if (firstPrm != null)
{
node3 = CreateJsExtensionDelegate(firstPrm, func);
}
}
}
}
// 其实以下的处理，也可以改代码，改成 Lambda 写法即可
// 这样子引用的并不是同一个函数，可能会造成内存泄露
if (res.TypeArguments.Count > 0 && info.Conversion.IsImplicit && me is SpecializedMethod)
{
var delegateFunc = node3 as JsInvocationExpression;
var sme = (SpecializedMethod)me;
var pars = sme.TypeArguments.Select(type => SkJs.EntityTypeRefToMember(type, false)).ToList();
pars.AddRange(sme.Parameters.Select(t => new JsCodeExpression
{
Code = JsIdentifier(t.Name),
}));
var body = delegateFunc == null?node3.Invoke(pars.ToArray()) : delegateFunc.Arguments[1].Invoke(pars.ToArray());
var func = new JsFunction()
{
Parameters = sme.Parameters.Select(t => JsIdentifier(t.Name)).ToList(),
};
JsStatement st;
if (sme.ReturnType.IsVoid())
{
st = new JsExpressionStatement {
Expression = body
};
}
else
{
st = new JsReturnStatement {
Expression = body
};
}
func.Block = new JsBlock {
Statements = new List <JsStatement> {
st
}
};
if (delegateFunc == null)
{
node3 = func;
}
else
{
delegateFunc.Arguments[1] = func;
}
}
return(node3);
}
