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)); }
protected virtual JsUnit OnAfterExportType(ITypeDefinition ce, JsClrType jsType) { //HACK: backward if (jsType.Kind == JsClrTypeKind.Interface && jsType.baseTypeName.IsNullOrEmpty()) { jsType.baseTypeName = "System.Object"; } var unit = new JsUnit { Statements = new List <JsStatement>() }; unit.Statements.Add(VerifyJsTypesArrayStatement.Clone()); var json = (JsJsonObjectExpression)Serialize(jsType); var moveToEnd = json.NamesValues.Where(t => t.Name.Name.Contains("definition")).ToList(); moveToEnd.ForEach(t => json.NamesValues.Remove(t)); json.NamesValues.AddRange(moveToEnd); var ceVarName = GetJsTypeName(ce).Replace(".", "$"); unit.Statements.Add(Js.Var(ceVarName, json).Statement()); unit.Statements.Add(Js.Member("JsTypes").Member("push").Invoke(Js.Member(ceVarName)).Statement()); return(unit); }
public override JsNode _VisitDelegate(ITypeDefinition ce) { var CurrentType = new JsClrType { Kind = JsClrTypeKind.Delegate }; CurrentType.fullname = GetJsTypeName(ce); //Generate constructor var genericParams = new List <ITypeParameter>(ce.GetGenericArguments()); var func = new JsFunction(); func.Parameters = genericParams.Select(t => t.Name).ToList(); func.Parameters.Add("obj"); func.Parameters.Add("func"); func.Block = Js.Block(); foreach (var ga in genericParams) { func.Block.Add(Js.This().Member(ga.Name).Assign(Js.Member(ga.Name)).Statement()); } func.Block.Add(Js.Members("System.MulticastDelegate.ctor.call").Invoke(Js.This(), Js.Member("obj"), Js.Member("func")).Statement()); CurrentType.GetDefinition(false)["ctor"] = func; return(OnAfterExportType(ce, CurrentType)); //return func; //FullName',{ ShortName:function(T1,T2,T3,...,obj,func){this.T1=T1;....;this.construct(obj,func);}, })"); }
public JsNode VisitUsingStatement(UsingStatement node) { var st3 = Visit(node.ResourceAcquisition); JsVariableDeclarationStatement stVar; if (st3 is JsExpression) { stVar = Js.Var("$r" + VariableResourceCounter++, (JsExpression)st3).Statement(); } else { stVar = (JsVariableDeclarationStatement)st3; } var trySt = VisitStatement(node.EmbeddedStatement); var st2 = new JsTryStatement { TryBlock = trySt.ToBlock(), FinallyBlock = Js.Block() }; //var resource = node.ResourceAcquisition; //var decl = resource as VariableDeclarationStatement; //if (decl == null || decl.Variables.Count == 0) // throw new Exception("using statement is supported only with the var keyword in javascript. Example: using(var g = new MyDisposable()){}"); foreach (var dr in stVar.Declaration.Declarators) { st2.FinallyBlock.Add(Js.Member(dr.Name).Member("Dispose").Invoke().Statement()); } return(Js.Block().Add(stVar).Add(st2)); //TODO: get rid of block }
public static JsMemberExpression EntityMethodToJsFunctionRef(IMethod me) { var ownerType = me.GetDeclaringTypeDefinition(); if (Sk.IsGlobalMethod(me)) { var member = Js.Member(SkJs.GetEntityJsName(me)); return(member); } else { var member = SkJs.EntityToMember(ownerType); if (!me.IsStatic) { if (Sk.IsNativeType(ownerType)) { member = member.Member("prototype"); } else { member = member.Member("commonPrototype"); } } member = member.Member(SkJs.GetEntityJsName(me)); return(member); } }
public JsNode VisitCSharpInvocationResolveResult(CSharpInvocationResolveResult res) { if (res.Member.IsConstructor()) { if (res.Type is AnonymousType) { //TODO: check context class JsType.NativeJsons var json = InitializersToJson(res.InitializerStatements, res.Type); var parentType = res.GetParentType(); if (parentType != null && !Sk.UseNativeJsons(parentType)) { return(Js.Member("$CreateAnonymousObject").Invoke(json)); } return(json); } else { return(VisitInvocationResolveResultAsCtor(res)); } } else { return(VisitInvocationResolveResult(res)); } }
void ExportNamespace(JsUnit unit, string ns) { var Writer = new StringWriter(); if (ns.IsNotNullOrEmpty()) { var tokens = ns.Split('.'); for (var i = 0; i < tokens.Length; i++) { var ns2 = tokens.Take(i + 1).StringJoin("."); JsStatement st; if (i == 0) { st = Js.Var(ns2, Js.Json()).Statement(); } else { st = Js.Member(ns2).Assign(Js.Json()).Statement(); } var st2 = Js.If(Js.Typeof(Js.Member(ns2)).Equal(Js.String("undefined"))).Then(st); unit.Statements.Add(st2); st2.AddAnnotation(new NamespaceVerificationAnnotation { Namespace = ns2 }); //.Ex(true).NamespaceVerification = ns2; } } }
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 VisitLocalResolveResult(LocalResolveResult res) { var node2 = Js.Member(JsIdentifier(res.Variable.Name)); if (res.Variable != null && res.Variable.Type.Kind == TypeKind.ByReference) { node2 = node2.Member("Value"); } return(node2); }
void YieldReturnInCurrentStep(JsExpression item) { var result = Js.Value(true); var stepIndex = Steps.Count - 1; AddToCurrentStep(Js.This().Member("_current").Assign(item).Statement()); AddToCurrentStep(_state().Assign(Js.Value(stepIndex + 1)).Statement()); AddToCurrentStep(Js.Member("result").Assign(result).Statement()); AddToCurrentStep(Js.Return(result)); }
public JsNode VisitInitializedObjectResolveResult(InitializedObjectResolveResult res) { var varName = Initializers.TryGetValue(res); if (varName == null) { varName = "$v" + VariableInitializerCounter++; Initializers[res] = varName; } return(Js.Member(varName)); }
protected virtual JsFunction GenerateAutomaticEventAccessor(IEvent ee, bool isRemove) { if (isRemove) { var remover = Js.Function("value").Add(Js.This().Member(ee.Name).Assign(Js.Member("$RemoveDelegate").Invoke(Js.This().Member(ee.Name), Js.Member("value"))).Statement()); return(remover); } var adder = Js.Function("value").Add(Js.This().Member(ee.Name).Assign(Js.Member("$CombineDelegates").Invoke(Js.This().Member(ee.Name), Js.Member("value"))).Statement()); return(adder); }
public static JsMemberExpression EntityToMember(IEntity me) { if (me == null) { return(null); } if (me.DeclaringType != null && (me.DeclaringType.IsGenericMethodArgument() || me.DeclaringType.IsGenericTypeParameter())) { var x = (JsMemberExpression)EntityTypeRefToMember(me.DeclaringType); var s = x.ToJs(); return(x); } var name = GetEntityJsName(me); if (me is ITypeDefinition) { return(Js.Member(name)); } else if (me.IsStatic()) { var member = Js.Member(name); if (Sk.IsGlobalMember(me)) { return(member); } if (me is IMethod && Sk.ExtensionImplementedInInstance((IMethod)me)) { return(member); } member.PreviousMember = EntityToMember(me.GetDeclaringTypeDefinition()); return(member); } else if (me.SymbolKind == SymbolKind.Constructor) { var att = Sk.GetJsMethodAttribute((IMethod)me); if (att != null && att.Name != null) //TODO: hack { return(Js.Member(att.Name)); } var ce = me.GetDeclaringTypeDefinition(); var member = EntityToMember(ce); var att2 = Sk.GetJsTypeAttribute(ce); if (att2 != null && att2.NativeConstructors) { return(member); } member = member.Member(name); return(member); } return(Js.Member(name)); }
public static JsReturnStatement GenerateYieldReturnStatement(IMethod me) { JsReturnStatement node2; if (me != null && me.ReturnType != null && me.ReturnType.FullName.StartsWith("System.Collections.Generic.IEnumerator")) { node2 = Js.Return(Js.Member("$yield").Member("GetEnumerator").Invoke()); } else { node2 = Js.Return(Js.Member("$yield")); } return(node2); }
public JsNode VisitYieldReturnStatement(YieldReturnStatement node) { var exp2 = VisitExpression(node.Expression); if (SupportClrYield) { return(new JsYieldReturnStatement { Expression = exp2 }); } var node2 = Js.Member("$yield.push").Invoke(exp2).Statement(); return(node2); }
public override JsNode _Visit(IProperty pe) { var list = GetAccessorsToExport(pe); if (Sk.IsNativeProperty(pe)) { var statements = new List <JsStatement>(); statements.AddRange(list.Select(ExportMethod).Cast <JsStatement>()); var json = new JsJsonObjectExpression(); foreach (var accessor in list) { if (accessor == pe.Getter) { json.Add("get", ExportTypePrefix(pe.Getter.GetDeclaringTypeDefinition(), pe.IsStatic).Member("get_" + pe.Name)); } if (accessor == pe.Setter) { json.Add("set", ExportTypePrefix(pe.Setter.GetDeclaringTypeDefinition(), pe.IsStatic).Member("set_" + pe.Name)); } } if (Sk.IsNativePropertyEnumerable(pe)) { json.Add("enumerable", Js.True()); } var defineStatement = Js.Member("Object").Member("defineProperty").Invoke( ExportTypePrefix(pe.GetDeclaringTypeDefinition(), pe.IsStatic), Js.String(pe.Name), json).Statement(); statements.Add(defineStatement); return(new JsUnit() { Statements = statements }); } else { var list2 = list.Select(ExportMethod).Cast <JsStatement>().ToList(); return(new JsUnit { Statements = list2 }); } }
public JsNode VisitYieldReturnStatement(YieldReturnStatement node) { qiucw.AddYieldReturn(node); var exp2 = VisitExpression(node.Expression); if (SupportClrYield) { return(new JsYieldReturnStatement { Expression = exp2 }); } //var node2 = Js.Member("$yield.push").Invoke(exp2).Statement(); //return node2; return(Js.Member("yield").Invoke(exp2).Statement()); }
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 VisitThrowStatement(ThrowStatement node) { JsExpression node2; IType exceptionType; if (node.Expression == null || node.Expression.IsNull) //happens when performing "throw;" { var cc = node.GetParent <CatchClause>(); if (cc != null) { node2 = Js.Member(cc.VariableName); var type = cc.Type; if (type == null || type.IsNull) { exceptionType = Project.Compilation.FindType(KnownTypeCode.Exception); } else { exceptionType = cc.Type.Resolve().Type; } } else { throw new Exception("Rethrow not supported, catch clause not found"); } } else { node2 = VisitExpression(node.Expression); var res = node.Expression.Resolve(); exceptionType = res.Type; if (res is ConversionResolveResult) { exceptionType = ((ConversionResolveResult)res).Input.Type; } } if (!Sk.IsNativeError(exceptionType.GetDefinitionOrArrayType())) { node2 = Js.Member("$CreateException").Invoke(node2, Js.New(Js.Member("Error"))); } return(new JsThrowStatement { Expression = node2 }); }
public void Process() { AfterFunction = BeforeFunction; SetParents(BeforeFunction.Block); foreach (var me in BeforeFunction.Block.Descendants <JsMemberExpression>().ToList()) { if (me.PreviousMember == null && me.NodeType == JsNodeType.MemberExpression) { me.PreviousMember = Js.This(); } } BeginNewStep(); ProcessStatement(BeforeFunction.Block); BeforeFunction.Block.Statements.Clear(); var func = new JsFunction { Block = new JsBlock { Statements = new List <JsStatement>() } }; var i = 0; func.Block.Statements.Add(Js.Var("result").Statement()); var stSwitch = Js.Switch(_state()); var lastStep = Js.Block().Add(_state().Assign(Js.Value(Steps.Count)).Statement()).Add(new JsBreakStatement()); Steps.Add(new YieldStep { Statements = { lastStep } }); foreach (var step in Steps) { stSwitch.Case(Js.Value(i), step.Statements); i++; } func.Block.Statements.Add(stSwitch); func.Block.Statements.Add(Js.Member("result").Assign(Js.Value(false)).Statement()); func.Block.Statements.Add(Js.Return(Js.Member("result"))); BeforeFunction.Block.Statements.Add(Js.Return(Js.New(Js.Member("CustomEnumerable"), func))); return; }
/// <summary> /// Wraps a setter invocation with a js function that returns the setter value back, if another assignment operation occurs /// var x = contact.Name = "Shooki"; /// var x = contact.setName("Shooki"); //error /// var x = (function(arg){contact.setName(arg);return arg;}).call(this, "Shooki"); /// </summary> /// <param name="res"></param> /// <param name="node2"></param> /// <returns></returns> internal JsNode WrapSetterToReturnValueIfNeeded(OperatorResolveResult res, JsNode node2) { var node3 = node2 as JsInvocationExpression; if (node3 == null) { return(node2); } if (RequiresWrapSetterToReturnValue(res)) { var lastArg = node3.Arguments.Last(); var prmName = "$p" + ParameterNameCounter++; node3.Arguments[node3.Arguments.Count - 1] = Js.Member(prmName); var func = Js.Function(prmName).Add(((JsExpression)node2).Statement()); func.Add(Js.Return(Js.Member(prmName))); node2 = WrapFunctionAndInvoke(res, func, lastArg); } return(node2); }
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 JsNode VisitUnknownMethodResolveResult(UnknownMethodResolveResult res) { return(Js.Member("UNKNOWN_METHOD")); }
public JsNode VisitTypeOfResolveResult(TypeOfResolveResult res) { return(Js.Member("Typeof").Invoke(SkJs.EntityTypeRefToMember(res.ReferencedType))); }
public JsNode VisitForeachStatement(ForeachStatement node) { if (node.InExpression != null) { var expRes = node.InExpression.Resolve(); var et = expRes.Type.GetDefinitionOrArrayType(); //var et = node.expression.entity_typeref.GetEntityType(); if (et != null) { var jta = Sk.GetJsTypeAttribute(et); if (jta != null && jta.NativeEnumerator) { var node2 = new JsForInStatement { Initializer = Js.Var(node.VariableName), Member = VisitExpression(node.InExpression), Statement = VisitStatement(node.EmbeddedStatement) }; return(node2); } else if (jta != null && jta.NativeArrayEnumerator) { VariableIteratorCounter++; var iteratorName = "$i" + VariableIteratorCounter; var lengthCacheName = "$l" + VariableIteratorCounter; var exp2 = VisitExpression(node.InExpression); var target = exp2; var targetCacheName = "$t" + VariableIteratorCounter; if (exp2.NodeType != JsNodeType.MemberExpression || ((JsMemberExpression)exp2).PreviousMember != null) //is not simple name { target = Js.Member(targetCacheName); } var itemAccess = target.IndexerAccess(Js.Member(iteratorName)); var node2 = new JsForStatement(); node2.Condition = Js.Member(iteratorName).LessThan(Js.Member(lengthCacheName)); node2.Iterators = new List <JsStatement> { Js.Member(iteratorName).PlusPlus().Statement(), Js.Member(node.VariableName).Assign(itemAccess).Statement() }; if (target != exp2) //use target caching { node2.Initializers = new List <JsStatement> { Js.Var(iteratorName, Js.Value(0)).AndVar(targetCacheName, exp2.Clone()).AndVar(lengthCacheName, target.Clone().Member("length")).AndVar(node.VariableName, itemAccess.Clone()).Statement() }; } else { node2.Initializers = new List <JsStatement> { Js.Var(iteratorName, Js.Value(0)).AndVar(lengthCacheName, exp2.Clone().Member("length")).AndVar(node.VariableName, itemAccess.Clone()).Statement() }; } node2.Statement = VisitStatement(node.EmbeddedStatement); return(node2); } } } var iteratorName2 = "$it" + VariableIteratorCounter; VariableIteratorCounter++; var node3 = Js.Var(iteratorName2, VisitExpression(node.InExpression).Member("GetEnumerator").Invoke()).Statement(); var whileNode = Js.While(Js.Member(iteratorName2).Member("MoveNext").Invoke()); var getCurrentStatement = Js.Var(node.VariableName, Js.Member(iteratorName2).Member("get_Current").Invoke()).Statement(); var jsStatement = VisitStatement(node.EmbeddedStatement); JsBlock block; if (jsStatement is JsBlock) { block = (JsBlock)jsStatement; } else { block = Js.Block().Add(jsStatement); } block.Statements.Insert(0, getCurrentStatement); whileNode.Statement = block; var block2 = Js.Block().Add(node3).Add(whileNode); return(block2); }
public JsNode VisitCatchClause(CatchClause node) { var node2 = new JsCatchClause(); if (node.VariableName.IsNullOrEmpty()) { node.VariableName = "$$e" + (VariableExceptionCounter++); //Generate a psuedo-unique variable name } node2.IdentifierName = node.VariableName; node2.Block = (JsBlock)Visit(node.Body); if (node2.Block != null) { node2.Descendants <JsThrowStatement>().Where(t => t.Expression == null).ForEach(t => t.Expression = Js.Member(node2.IdentifierName)); } return(node2); }
void TransformIntoBaseMethodCallIfNeeded(CSharpInvocationResolveResult res, JsInvocationExpression node2) { var target = res.TargetResult as ThisResolveResult; if (target != null && target.CausesNonVirtualInvocation) //base. { //var info = res.GetInfo(); //var node = info.Nodes.FirstOrDefault(); var ce = target.Type;// node.FindThisEntity(); if (ce != null && Sk.IsExtJsType(ce.GetDefinitionOrArrayType())) { node2.Member = Js.This().Member("callParent"); if (node2.Arguments.IsNotNullOrEmpty()) { node2.Arguments = new List <JsExpression> { Js.NewJsonArray(node2.Arguments.ToArray()) } } ; //var me2 = (node2.Member as JsMemberExpression); //me2.Name = "callParent"; return; } IMethod me2; var me = res.Member; if (me is IProperty) { me2 = ((IProperty)me).Getter; } else if (me is IMethod) { me2 = (IMethod)res.Member; } else { throw new Exception("Can't resolve method from member: " + res.Member); } var member = SkJs.EntityMethodToJsFunctionRef(me2); member = member.Member("call"); node2.Member = member; if (node2.Arguments == null) { node2.Arguments = new List <JsExpression>(); } node2.Arguments.Insert(0, Js.This()); } } void ProcessByRefs1() { ByRefs = new List <ByReferenceResolveResult>(); ByRefIndexes = new List <int>(); RefToRefs = new List <int>(); var c = 0; foreach (var bin in PrmBindings) { var binding = bin.Binding; 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); ByRefIndexes.Add(c); c++; } } void ProcessByRefs2() { var c = 0; for (var i = 0; i < Node2.Arguments.Count; i++) { if (Node2.Arguments[i] is JsMemberExpression) { JsMemberExpression jsmex = Node2.Arguments[i] as JsMemberExpression; if (RefToRefs.Contains(i)) { Node2.Arguments[i] = jsmex.PreviousMember; //remove the .Value ref wrapper } else if (ByRefIndexes.Contains(i)) { Node2.Arguments[i] = Js.Member(RefIndexToName(c)); c++; } } else if (Node2.Arguments[i] is JsIndexerAccessExpression) { if (ByRefIndexes.Contains(i)) { Node2.Arguments[i] = Js.Member(RefIndexToName(c)); c++; } } } } void ProcessByRefs3() { if (ByRefs.IsNotNullOrEmpty()) { var func = Js.Function(); //It must assigned to a temporary variable, because typed arrays do not acceppt json. //调整原来使用临时对象.Value的赋值方式,修改为Object.defineProperty定义get|set方法的实现 //临时对象统一调用jsclr里的$Ref方法进行创建 for (var i = 0; i < ByRefs.Count; i++) { var byRef = ByRefs[i]; var expr = VisitExpression(byRef); if (expr is JsMemberExpression) { var memberExpr = expr as JsMemberExpression; if (memberExpr.PreviousMember != null) { var refFuncInvoke = new JsInvocationExpression { Member = new JsMemberExpression { Name = "$Ref" }, Arguments = new List <JsExpression> { memberExpr.PreviousMember, Js.String(memberExpr.Name) } }; func.Add(Js.Var(RefIndexToName(i), refFuncInvoke).Statement()); } else { //如果是局部变量的话使用旧实现方式 var refFuncInvoke = new JsInvocationExpression { Member = new JsMemberExpression { Name = "$Ref" }, Arguments = new List <JsExpression> { Js.Member("null"), memberExpr } }; func.Add(Js.Var(RefIndexToName(i), refFuncInvoke).Statement()); } } else if (expr is JsIndexerAccessExpression) { var indexerExpr = expr as JsIndexerAccessExpression; var indexArg = indexerExpr.Arguments[0]; var refFuncInvoke = new JsInvocationExpression { Member = new JsMemberExpression { Name = "$Ref" }, Arguments = new List <JsExpression> { indexerExpr.Member, indexArg } }; func.Add(Js.Var(RefIndexToName(i), refFuncInvoke).Statement()); } } func.Add(Js.Var("$res", Node2).Statement()); for (var i = 0; i < ByRefs.Count; i++) { var byRef = ByRefs[i]; var memberExpr = VisitExpression(byRef) as JsMemberExpression; if (memberExpr != null && memberExpr.PreviousMember == null) { func.Add(memberExpr.Assign(Js.Member(RefIndexToName(i)).Member("Value")).Statement()); } } func.Add(Js.Return(Js.Member("$res"))); Node2 = Importer.WrapFunctionAndInvoke(Res, func); } }
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 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)); }
private JsInvocationExpression ExportDefault(IType type) { return(Js.Member("Default").Invoke(SkJs.EntityTypeRefToMember(type))); }