JsMode GetJsMode(ITypeDefinition ce)
{
var isGlobal = Sk.IsGlobalType(ce);
if (isGlobal)
{
return(JsMode.Global);
}
var isNative = Sk.IsNativeType(ce);
if (isNative)
{
return(JsMode.Prototype);
}
return(JsMode.Clr);
}
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);
}
MemberConverter GetMemberConverter(ITypeDefinition ce)
{
MemberConverter export;
var isExtJs = Sk.IsExtJsType(ce);
var isGlobal = Sk.IsGlobalType(ce) && !isExtJs;
var isNative = Sk.IsNativeType(ce) && !isExtJs;
if (isGlobal)
{
if (GlobalConverter == null)
{
GlobalConverter = new MemberConverter_Global();
}
export = GlobalConverter;
}
else if (isNative)
{
if (NativeConverter == null)
{
NativeConverter = new MemberConverter_Native();
}
export = NativeConverter;
}
else if (isExtJs)
{
if (ExtJsConverter == null)
{
ExtJsConverter = new MemberConverter_ExtJs();
}
export = ExtJsConverter;
}
else
{
if (ClrConverter == null)
{
ClrConverter = new MemberConverter_Clr();
}
export = ClrConverter;
}
OnConfigureMemberConverter(export);
return(export);
}
/// <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 (Sk.IsClrType(baseClass.GetDefinition()) || (Sk.IsNativeType(baseClass.GetDefinition()) && !Sk.IsGlobalType(baseClass.GetDefinition())) || !recursive)
{
return(baseClass);
}
baseClass = baseClass.GetBaseType();
}
return(null);
}
protected JsBlock 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 = (JsBlock)AstNodeConverter.Visit(ccc);
if (block2 == null)
{
block2 = new JsBlock {
Statements = new List <JsStatement>()
}
}
;
var ce = ctor.GetDeclaringTypeDefinition();
var isClr = Sk.IsClrType(ce);
var isPrototype = Sk.IsNativeType(ce);
var statements = new List <JsStatement>();
//instance fields initializations
if (!Sk.InlineFields(ce))
{
var isGlobal = Sk.IsGlobalType(ce);
var fields = GetExportedDeclaredAndGeneratedFields(ce, ctor.IsStatic);
//var fields = ctor.GetDeclaringTypeDefinition().GetFields(null, GetMemberOptions.IgnoreInheritedMembers).Where(t => t.IsStatic() == ctor.IsStatic).ToList();
//fields = fields.Where(ShouldExportField).ToList();
//fields.AddRange(GeneratePropertyFields(ctor.DeclaringTypeDefinition, ctor.IsStatic));
//var props = ctor.GetDeclaringTypeDefinition().GetProperties(null, GetMemberOptions.IgnoreInheritedMembers).Where(t => t.IsStatic() == ctor.IsStatic).ToList();
//props = props.Where(t=>Sk.IsNativeField(t)).ToList();
//props = props.Where(t => Sk.IsJsExported(t)).ToList();
//var fieldsAndProperties = fields.Cast<IEntity>().Concat(props.Cast<IEntity>());
var initializers = fields.Select(fe => ExportInitializer(fe, null, isGlobal, false)).Cast <JsStatement>().ToList();
if (initializers.Contains(null))
{
Log.Warn("Some field initializers were not exported");
}
statements.AddRange(initializers.Where(t => t != null));
}
if (!ctor.IsStatic)
{
//base/this ctor invocation
var invocation = GetConstructorBaseOrThisInvocation2(ctor);
if (invocation != null)
{
var baseThisCe = invocation.Member.DeclaringType;
var isBaseClr = Sk.IsClrType(baseThisCe.GetDefinition());
var isBasePrototype = Sk.IsNativeType(baseThisCe.GetDefinition()) && !Sk.IsJsonMode(baseThisCe.GetDefinition()) && !Sk.IsGlobalType(baseThisCe.GetDefinition()); //happens when prototype inherits from json
if (isBaseClr == isClr && isBasePrototype == isPrototype) //base and derived are both prototype, or both are clr
{
var newObjExp2 = AstNodeConverter.VisitExpression(invocation);
JsInvocationExpression invocation2;
if (newObjExp2 is JsNewObjectExpression)
{
var newObjExp = (JsNewObjectExpression)newObjExp2;
invocation2 = newObjExp.Invocation;
}
else if (newObjExp2 is JsInvocationExpression)
{
invocation2 = (JsInvocationExpression)newObjExp2;
}
else
{
throw new Exception("Unexpected node: " + newObjExp2);
}
if (Sk.IsExtJsType(ce))
{
var invocation3 = Js.This().Member("callParent").Invoke();
if (invocation2.Arguments.IsNotNullOrEmpty())
{
invocation3.Arguments = new List <JsExpression> {
Js.NewJsonArray(invocation2.Arguments.NotNull().ToArray())
}
}
;
statements.Add(invocation3.Statement());
}
else
{
JsRefactorer.ToCallWithContext(invocation2, new JsThis());
statements.Add(invocation2.Statement());
}
}
}
}
if (block2.Statements == null)
{
block2.Statements = new List <JsStatement>();
}
block2.Statements.InsertRange(0, statements);
return(block2);
}
void ExportConstructorParameters(IMethod ctor, JsFunction func)
{
var ce = ctor.GetDeclaringTypeDefinition();
var list = new List <string>();
if (!Sk.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, Js.This().Member(gprm.Name).Assign(Js.Member(gprm.Name)).Statement());
i++;
}
}
}
}
var prms = ctor.Parameters;
if (prms != null)
{
func.Parameters.AddRange(prms.Select(t => t.Name));
}
}