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);
}
}
/// <summary>
/// Returns base type of a type, only if base type is Clr or Prototype
/// </summary>
/// <param name="ce"></param>
/// <returns></returns>
protected virtual IType GetBaseClassIfValid(ITypeDefinition ce, bool recursive)
{
var baseClass = ce.GetBaseType();
while (baseClass != null)
{
if (JMeta.IsClrType(baseClass.GetDefinition()) || (JMeta.IsNativeType(baseClass.GetDefinition()) && !JMeta.IsGlobalType(baseClass.GetDefinition())) || !recursive)
{
return(baseClass);
}
baseClass = baseClass.GetBaseType();
}
return(null);
}
JsMode GetJsMode(ITypeDefinition ce)
{
var isGlobal = JMeta.IsGlobalType(ce);
if (isGlobal)
{
return(JsMode.Global);
}
var isNative = JMeta.IsNativeType(ce);
if (isNative)
{
return(JsMode.Prototype);
}
return(JsMode.Clr);
}
private void SortByNativeInheritance(List <ITypeDefinition> list)
{
var list2 = list.Where(t => JMeta.IsNativeType(t) && t.GetBaseTypeDefinition() != null && JMeta.IsNativeType(t.GetBaseTypeDefinition())).ToList();
foreach (var ce in list2)
{
var ce3 = ce;
while (true)
{
var baseCe = ce3.GetBaseTypeDefinition();
if (baseCe == null)
{
break;
}
MoveBefore(list, ce3, baseCe);
ce3 = baseCe;
}
}
}
private JTypeImporter GetTypeImporter(ITypeDefinition ce)
{
JTypeImporter export;
var isExtJs = JMeta.IsExtJsType(ce);
var isGlobal = JMeta.IsGlobalType(ce) && !isExtJs;
var isNative = JMeta.IsNativeType(ce) && !isExtJs;
isNative = true;
isGlobal = false;
isExtJs = false;
if (isGlobal)
{
throw new NotSupportedException();
}
else if (isNative)
{
if (NativeExport == null)
{
NativeExport = new JTypeImporter {
Compiler = Compiler
}
}
;
export = NativeExport;
}
else if (isExtJs)
{
throw new NotSupportedException();
}
else
{
throw new NotSupportedException();
}
ConfigureTypeExport(export);
return(export);
}
protected JBlock ExportConstructorBody(IMethod ctor)
{
var ctorNode = (ConstructorDeclaration)ctor.GetDeclaration();
BlockStatement ccc = null;
if (ctorNode != null)
{
ccc = ctorNode.Body;
}
//var ccc = ctor.GetDefinition();//.decl as CsConstructor;
//var ccc = ctor.GetDefinition();
var block2 = (JBlock)JsCodeImporter.Visit(ccc);
if (block2 == null)
{
block2 = new JBlock {
Statements = new List <JStatement>()
}
}
;
var ce = ctor.GetDeclaringTypeDefinition();
var isClr = JMeta.IsClrType(ce);
var isPrototype = JMeta.IsNativeType(ce);
var statements = new List <JStatement>();
if (!ctor.IsStatic)
{
//TODO:
//base/this ctor invocation
var invocation = GetConstructorBaseOrThisInvocation2(ctor);
if (invocation.Arguments.Count > 0)
{
var exp2 = (JNewObjectExpression)JsCodeImporter.VisitExpression(invocation);
var exp3 = exp2.Invocation;
exp3.Member = J.Member("super");
statements.Insert(0, exp3.Statement());
}
}
if (block2.Statements == null)
{
block2.Statements = new List <JStatement>();
}
block2.Statements.InsertRange(0, statements);
return(block2);
}
void ExportConstructorParameters(IMethod ctor, JFunction func)
{
var ce = ctor.GetDeclaringTypeDefinition();
var list = new List <string>();
if (!JMeta.IgnoreTypeArguments(ce))
{
//danel
var gprms = ce.TypeParameters.ToList();//.GetGenericArguments().Where(ga => ga.isGenericParam()).ToList();
if (gprms.IsNotNullOrEmpty())
{
var i = 0;
foreach (var gprm in gprms)
{
func.Parameters.Add(gprm.Name);
if (!ctor.IsStatic && func.Block != null)
{
func.Block.Statements.Insert(i, J.This().Member(gprm.Name).Assign(J.Member(gprm.Name)).Statement());
i++;
}
}
}
}
var prms = ctor.Parameters;
if (prms != null)
{
func.Parameters.AddRange(prms.Select(t => t.Name));
}
}
