public static JMemberExpression EntityMethodToJsFunctionRef(IMethod me)
{
var ownerType = me.GetDeclaringTypeDefinition();
if (JMeta.IsGlobalMethod(me))
{
var member = J.Member(JNaming.JName(me));
return(member);
}
else
{
var member = JNaming.JAccess(ownerType);
if (!me.IsStatic)
{
if (JMeta.IsNativeType(ownerType))
{
member = member.Member("prototype");
}
else
{
member = member.Member("commonPrototype");
}
}
member = member.Member(JNaming.JName(me));
return(member);
}
}
protected IField GenerateBackingField(IProperty pe)
{
var field = GenerateFakeField(pe);
field.Name = JNaming.JName(pe).ToJavaNaming();
return(field);
}
private JExpression InitializersToJson(IList <ResolveResult> initializerStatements, IType type)
{
if (type.GetMethods(t => t.Name == "Add").FirstOrDefault() != null)
{
var items = initializerStatements.Cast <CSharpInvocationResolveResult>().Select(t => t.Arguments[0]).ToList();
var items2 = VisitExpressions(items);
var arr = J.NewJsonArray(items2.ToArray());
return(arr);
}
else
{
var json = J.Json();
foreach (var st in initializerStatements)
{
if (st is OperatorResolveResult)
{
var op = (OperatorResolveResult)st;
var mrr = (MemberResolveResult)op.Operands[0];
var name = JNaming.JName(mrr.Member);
var value = VisitExpression(op.Operands[1]);
json.Add(name, 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);
}
}
private static JMemberExpression GetClassName(ITypeDefinition ce)
{
var name = JNaming.JName2(ce).RemoveGenericArgs();
name.PreviousMember = null;
return(name);
}
public JNode VisitMemberResolveResult(MemberResolveResult res)
{
var me = res.Member;
JNode 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 (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() && JMeta.UseJsonEnums(me, out enumValuesAsNames))
{
var me2 = (IField)me;
if (enumValuesAsNames)
{
return(J.String(JNaming.JName(me2)));
}
else
{
return(J.Value(me2.ConstantValue));
}
}
//TODO: Support a way to override this (JsField.ConstantInlining=false)
else if (res.IsCompileTimeConstant && !me.IsEnumMember())
{
return(J.Value(res.ConstantValue));
}
else
{
var node3 = JNaming.JAccess(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);
}
private string GetJFilename(ITypeDefinition ce)
{
var outputDir = "out";
var att = JMeta.GetJsExportAttribute(Project.Compilation.MainAssembly);
if (att != null && att.OutputDir != null)
{
outputDir = att.OutputDir;
}
return(Path.Combine(outputDir, JNaming.JName2(ce).RemoveGenericArgs().ToJs().Replace(".", "\\") + ".java"));
}
public JNode VisitTypeIsResolveResult(TypeIsResolveResult res)
{
var typeDef = res.TargetType.GetDefinitionOrArrayType(Compiler);
//if (Sk.OmitCasts(typeDef))
//{
// return J.True();
// //var node2 = Visit(res.Input);
// //return node2;
//}
//else
//{
var node2 = VisitExpression(res.Input).InstanceOf(JNaming.JAccess(res.TargetType));
return(node2);
//}
}
public virtual List <JEntityDeclaration> ExportMethod(IMethod me)
{
var jma = JMeta.GetJMethodAttribute(me);
if (jma != null && (jma.Global || jma.GlobalCode))
{
throw new NotSupportedException();
//return CreateGlobalImporter().ExportMethod(me);
}
else
{
var ce = me.GetDeclaringTypeDefinition();
var member = me.JAccess();
var func = new JFunction();
//func.Name = me.Name;
func.Parameters = ExportMethodParameters(me);
func.Block = ExportMethodBody(me);
if (JsCodeImporter.SupportClrYield)
{
func = ApplyYield(func);
}
var typeParams = me.TypeParameters.Select(t => t.JAccess()).ToList();
var decl = new JMethodDeclaration
{
Name = JNaming.JName(me),
MethodDefinition = me,
MethodBody = func.Block,
Parameters = ExportParameters(me.Parameters),
Type = me.ReturnType.JAccess(),
TypeParameters = typeParams,
};
ImportModifiers(me, decl);
if (me.IsOverride || me.ImplementedInterfaceMembers.IsNotNullOrEmpty())
{
decl.Annotations.Add(new JAnnotationDeclaration {
Name = "Override"
});
}
return(new List <JEntityDeclaration> {
decl
});
}
}
public virtual List <JEntityDeclaration> _VisitField(IField fld)
{
var init2 = GetCreateFieldInitializer(fld);
JExpression initializer = null;
if (init2 != null)
{
initializer = JsCodeImporter.VisitExpression(init2);
}
var fe2 = new JFieldDeclaration
{
FieldDefinition = fld,
Initializer = initializer,
Type = fld.Type.JAccess(),
Name = JNaming.JName(fld)
};
ImportModifiers(fld, fe2);
return(new List <JEntityDeclaration> {
fe2
});
}
public JNode VisitConstantResolveResult(ConstantResolveResult res)
{
var nodes = res.GetNodes();
if (res.Type is DefaultTypeParameter)
{
return(J.Member("Default").Invoke(JNaming.JAccess(res.Type)));
}
if (res.Type != null && res.Type.Kind == TypeKind.Enum)
{
return(Visit(JTypeImporter.GetValueTypeInitializer(res.Type, Compiler)));
}
//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(J.Value(res.ConstantValue));
}
private JNode VisitInvocationResolveResult(CSharpInvocationResolveResult res)
{
////TODO: LET LINQ
//var firstNode = res.GetFirstNode();
//if (firstNode != null && firstNode is QueryLetClause)
//{
// foreach (var arg in res.Arguments)
// {
// if (arg.GetInfo() == null)
// arg.SetInfo(new ResolveResultInfo { Nodes = { firstNode } });
// }
//}
var member = res.Member;
var me = member as IMethod;
if (me == null)
{
var pe = member as IProperty;
if (pe != null)
{
me = pe.Getter;
member = me;
}
}
var att = me != null?JMeta.GetJMethodAttribute(me) : null;
if (att != null && att.InlineCode != null)
{
return(J.Code(att.InlineCode));
}
//TODO: move defines locally
var condAtt = me.GetMetadata <System.Diagnostics.ConditionalAttribute>();
if (condAtt != null && Compiler != null && Compiler.Defines != null && !Compiler.Defines.Contains(condAtt.ConditionString))
{
return(null);
}
if (att != null && att.OmitCalls)
{
if (me.IsStatic() && !me.IsExtensionMethod)
{
return(null);
}
if (me.IsExtensionMethod && !res.IsExtensionMethodInvocation)
{
return(null);
}
if (res.Arguments.IsEmpty() && res.TargetResult != null)
{
return(VisitExpression(res.TargetResult));
}
return(Visit(res.Arguments[0]));
}
var jsMember = JNaming.JAccess(member);
if (res.TargetResult != null && !member.IsStatic() && member.SymbolKind != SymbolKind.Constructor) //TargetResult==null when ctor
{
var target = VisitExpression(res.TargetResult);
if (jsMember.PreviousMember != null)
{
throw new NotSupportedException();
}
jsMember.PreviousMember = target;
}
var bindings = res.GetArgumentsForCall2();
if (JMeta.OmitOptionalParameters(me))
{
bindings.RemoveAll(t => t.ArgResult == null);
}
if (JMeta.IsNativeParams(me))
{
var binding = bindings.Where(t => t.Parameter.IsParams).FirstOrDefault();
if (binding != null)
{
if (binding.CallResult is ArrayCreateResolveResult)
{
var arrayRes = (ArrayCreateResolveResult)binding.CallResult;
bindings.Remove(binding);
if (arrayRes.InitializerElements.IsNotNullOrEmpty())
{
foreach (var init in arrayRes.InitializerElements)
{
var b = binding.Clone();
b.CallResult = init;
bindings.Add(b);
}
}
}
else
{
Log.Warn(res.GetFirstNode(), "Invalid params parameter passed to method with NativeParams=true");
}
}
}
var byRefs = new List <ByReferenceResolveResult>();
List <int> refToRefs = new List <int>();
var c = 0;
foreach (var binding in bindings)
{
var byRef = binding.CallResult as ByReferenceResolveResult;
if (byRef == null)
{
c++;
continue;
}
var x = byRef.ElementResult as LocalResolveResult;
if (x != null && x.Variable != null && x.Variable.Type.Kind == TypeKind.ByReference)
{
if (binding.Parameter.IsRef || binding.Parameter.IsOut)
{
refToRefs.Add(c);
}
c++;
continue;
}
byRefs.Add(byRef);
c++;
}
var callArgs = bindings.Select(t => t.CallResult).ToList();
var node2 = new JInvocationExpression
{
Member = jsMember,
Arguments = VisitExpressions(callArgs),
};
foreach (var i in refToRefs)
{
JMemberExpression jsmex = node2.Arguments[i] as JMemberExpression;
if (jsmex != null)
{
node2.Arguments[i] = jsmex.PreviousMember;//remove the .Value ref wrapper
}
}
if (me != null && me.IsExtensionMethod && res.IsExtensionMethodInvocation && JMeta.ExtensionImplementedInInstance(me))
{
var arg = node2.Arguments[0];
node2.Arguments.RemoveAt(0);
if (jsMember.PreviousMember != null)
{
throw new NotImplementedException();
}
jsMember.PreviousMember = arg;
}
TransformIntoBaseMethodCallIfNeeded(res, node2);
if (att != null)
{
if (att.OmitParanthesis)
{
node2.OmitParanthesis = true;
}
if (node2.Arguments == null)
{
node2.Arguments = new List <JExpression>();
}
if (att.InsertArg2 != null)
{
node2.Arguments.InsertOrAdd(2, new JCodeExpression {
Code = att.InsertArg2.ToString()
});
}
if (att.InsertArg1 != null)
{
node2.Arguments.InsertOrAdd(1, new JCodeExpression {
Code = att.InsertArg1.ToString()
});
}
if (att.InsertArg0 != null)
{
node2.Arguments.InsertOrAdd(0, new JCodeExpression {
Code = att.InsertArg0.ToString()
});
}
node2.OmitCommas = att.OmitCommas;
node2.ArgumentsPrefix = att.ArgumentsPrefix;
node2.ArgumentsSuffix = att.ArgumentsSuffix;
if (att.InstanceImplementedAsExtension)
{
var ext = (JMemberExpression)node2.Member;
node2.Arguments.Insert(0, ext.PreviousMember);
ext.PreviousMember = null;
}
}
//if (me != null && me is SpecializedMethod && !Sk.IgnoreGenericMethodArguments(me))
//{
// List<JsExpression> genericArgs;
// if (me.IsConstructor)
// {
// var ce = me.DeclaringType as ParameterizedType;
// if (ce != null)
// genericArgs = ce.TypeArguments.Select(t => SkJs.EntityTypeRefToMember(t, true)).ToList();
// else
// genericArgs = new List<JsExpression>();
// }
// else
// {
// var sme = (SpecializedMethod)me;
// genericArgs = sme.TypeArguments.Select(t => SkJs.EntityTypeRefToMember(t, true)).ToList();
// }
// if (node2.Arguments == null)
// node2.Arguments = new List<JsExpression>(genericArgs);
// else
// node2.Arguments.InsertRange(0, genericArgs);
//}
if (att != null && att.OmitDotOperator)
{
if (node2.Member is JMemberExpression && node2.Arguments.Count == 1 && att.OmitParanthesis)
{
var meNode = (JMemberExpression)node2.Member;
var node3 = new JBinaryExpression {
Left = meNode.PreviousMember, Operator = meNode.Name, Right = node2.Arguments[0]
};
return(node3);
}
else
{
Log.Warn(res.GetFirstNode(), "TODO:OmitDotOperator is not supported in this syntax.");
}
}
if (node2.Member is JMemberExpression)
{
var x = (JMemberExpression)node2.Member;
if (x.Name.IsNullOrEmpty() && jsMember.PreviousMember != null)
{
node2.Member = x.PreviousMember;
}
}
if (res.Member.SymbolKind == SymbolKind.Indexer && JMeta.UseNativeIndexer((IProperty)res.Member))
{
var node3 = new JIndexerAccessExpression
{
Member = node2.Member,
Arguments = node2.Arguments,
};
return(node3);
}
if (byRefs.IsNotNullOrEmpty())
{
var func = J.Function();
foreach (var byRef in byRefs)
{
func.Add(J.Assign(VisitExpression(byRef), J.Json().Add("Value", VisitExpression(byRef))).Statement());
}
func.Add(J.Var("$res", res.Type.JAccess(), node2).Statement());
foreach (var byRef in byRefs)
{
func.Add(J.Assign(VisitExpression(byRef), VisitExpression(byRef).Member("Value")).Statement());
}
func.Add(J.Return(J.Member("$res")));
var node5 = WrapFunctionAndInvoke(res, func.Block);
return(node5);
}
return(node2);
}
private JNode 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)
{
var me = conversion.Method;
var delType = conversionType;
var exp = me.JAccess().Invoke(me.Parameters.Select(t => J.Member(t.Name)).ToArray());
var st = J.Return(exp);
var block = J.Block().Add(st);
var del2 = CreateDelegate(delType, me.Parameters, me.ReturnType, block);
return(del2);
//J.CreateDelegate(conversionType.JAccess(), me.Parameters.Select(t=>t.Acc
//TODO: J.CreateDelegate(conversionType.JAccess(),
}
else if (conversion.IsUserDefined)
{
ITypeDefinition typeDef;
if (conversion.Method != null && conversion.Method.DeclaringType != null)
{
typeDef = conversion.Method.DeclaringType.GetDefinitionOrArrayType(Compiler);
}
else
{
typeDef = conversionType.GetDefinitionOrArrayType(Compiler);
}
var nativeOverloads = JMeta.UseNativeOperatorOverloads(typeDef);
if (nativeOverloads)
{
return(Visit(input));
}
var fake = conversion.Method.InvokeMethod(null, input);
var node2 = Visit(fake);
return(node2);
}
else if (conversion.IsTryCast || conversion.IsExplicit)
{
var typeDef = conversionType.GetDefinitionOrArrayType(Compiler);
var omitCasts = JMeta.OmitCasts(typeDef, Project);
if (omitCasts)
{
return(Visit(input));
}
if (true)//Sk.NativeCasts(typeDef))
{
var exp2 = VisitExpression(input);
var type2 = JNaming.JAccess(conversionType);
if (conversion.IsTryCast)
{
var node2 = exp2.InstanceOf(type2).Conditional(exp2, J.Null());
return(node2);
}
else
{
return(J.Cast(exp2, type2));
}
}
//else
//{
// var cast = conversion.IsTryCast ? "As" : "Cast";
// var node2 = J.Member(cast).Invoke(VisitExpression(input), JNaming.JAccess(conversionType));
// return node2;
//}
}
return(Visit(input));
}
public JNode VisitTypeResolveResult(TypeResolveResult res)
{
return(JNaming.JAccess(res.Type));
//throw new NotImplementedException();
}
public JNode VisitTypeOfResolveResult(TypeOfResolveResult res)
{
return(J.Member("Typeof").Invoke(JNaming.JAccess(res.ReferencedType)));
}
public JNode 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);//TODO: IsExtensionMethodStyle(new CsInvocationExpression { entity = me, expression = node });
JExpression firstPrm = null;
if (isExtensionMethodStyle)
{
firstPrm = (JExpression)Visit(res.TargetResult);
}
var node2 = JNaming.JAccess(me);
JExpression node3;
JExpression 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 || !JMeta.ForceDelegatesAsNativeFunctions(parentMethod))
{
if (parentMethod == null)
{
Log.Warn(info.Nodes.FirstOrDefault(), "GetParentMethod() returned null");
}
var func = (JExpression)node2;
if (instanceContext != null)
{
node3 = CreateJsDelegate(instanceContext, func);
}
else if (firstPrm != null)
{
node3 = CreateJsExtensionDelegate(firstPrm, func);
}
}
}
}
return(node3);
}
protected JBlock ExportMethodBody(IMethod me)
{
if (me.DeclaringTypeDefinition.IsInterface())
{
return(null);
}
if (CompilerConfig.Current.EnableLogging)
{
Log.Debug("JsTypeImporter: Visit Method: " + me.ToString());
}
var nativeCode = JMeta.GetNativeCode(me);
if (nativeCode != null)
{
var block = J.Block().Add(J.Code(nativeCode).Statement()); //TODO: double semicolon?
var x = block.ToJs();
return(block);
}
var def = me.GetDefinition();
if (def == null || def.IsNull)
{
if (me.DeclaringTypeDefinition.IsDelegate())
{
var block = J.Block();
if (!me.ReturnType.IsVoid())
{
block.Add(J.Return(J.Null()));
}
return(block);
}
if (me.IsAutomaticEventAccessor())
{
if (me.IsEventAddAccessor())
{
var node = GenerateAutomaticEventAccessor((IEvent)me.GetOwner(), false);
return(node.Block);
}
else if (me.IsEventRemoveAccessor())
{
var node = GenerateAutomaticEventAccessor((IEvent)me.GetOwner(), true);
return(node.Block);
}
}
else if (me.IsAutomaticPropertyAccessor())
{
var bf = J.Member(JNaming.JName(me.AccessorOwner).ToJavaNaming());
if (!me.IsStatic)
{
bf.PreviousMember = J.This();
}
else if (!JMeta.IsGlobalMethod(me))
{
bf.PreviousMember = JNaming.JAccess(me.DeclaringType);
}
if (me.IsGetter())
{
return(J.Block().Add(J.Return(bf)));
}
else
{
return(J.Block().Add(bf.Assign(J.Member("value")).Statement()));
}
}
return(null);
}
var block2 = (JBlock)JsCodeImporter.Visit(def);
if (def.Descendants.OfType <YieldReturnStatement>().FirstOrDefault() != null)
{
if (!JsCodeImporter.SupportClrYield)
{
if (block2.Statements == null)
{
block2.Statements = new List <JStatement>();
}
var arg = me.ReturnType.TypeArguments[0].JAccess();
var listType = J.Members("java.util.ArrayList").AddGenericArg(arg);
var yieldVar = J.Var("$yield", listType, J.New(listType)).Statement();
block2.Statements.Insert(0, yieldVar);
block2.Statements.Add(JCodeImporter.GenerateYieldReturnStatement(me));
}
}
return(block2);
}
