public override JsNode _VisitEnum(ITypeDefinition ce)
{
var CurrentType = new JsClrType { Kind = JsClrTypeKind.Enum };
CurrentType.fullname = GetJsTypeName(ce);
var json = VisitEnumToJson(ce);
foreach (var item in json.NamesValues)
{
////TODO: baseType (long, byte, etc...)
//foreach (var pe in ce.GetConstants())
//{
//var name = pe.Name;
CurrentType.GetDefinition(true)[item.Name.Name] = item.Value;
// }
}
return OnAfterExportType(ce, CurrentType);
}
protected override JsUnit OnAfterExportType(ITypeDefinition ce, JsClrType jsType)
{
var extJsType = new ExtJsType
{
extend = jsType.baseTypeName,
statics = jsType.staticDefinition,
};
//if (extJsType.extend == "System.Object")
// extJsType.extend = null;
var json = (JsJsonObjectExpression)Serialize(extJsType);
//var ctor = json.NamesValues.Where(t => t.Name.Name == "ctor").FirstOrDefault();
if (jsType.definition == null)
jsType.definition = new JsObject();
var ctor = jsType.definition.TryGetValue("ctor");
if (ctor != null)
{
jsType.definition.Remove("ctor");
jsType.definition.Add("constructor", ctor);
//ctor.Name.Name = "constructor";
//var func = ctor.Value as JsFunction;
//if (func != null)
//{
// func.Block.Statements.Insert(0, Js.This().Member("callSuper").Invoke(Js.Member("arguments")).Statement());
//}
}
foreach (var me in jsType.definition)
{
var name = me.Key;
var value = (JsExpression)me.Value;
if (json.NamesValues == null)
json.NamesValues = new List<JsJsonNameValue>();
json.NamesValues.Add(new JsJsonNameValue { Name = new JsJsonMember { Name = name }, Value = value });
}
var define = Js.Members("Ext.define").Invoke(Js.String(jsType.fullname), json).Statement();
var unit = new JsUnit { Statements = new List<JsStatement> { define } };
return unit;// base.OnAfterExportType(ce, jsType);
}
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);}, })");
}
private void ExportImplementedInterfaces(ITypeDefinition ce, JsClrType jsType)
{
var list = ce.DirectBaseTypes.Where(t => t.Kind == TypeKind.Interface).ToList();
if (list.Count == 0)
return;
if (jsType.interfaceNames == null)
jsType.interfaceNames = new JsArray<string>();
jsType.interfaceNames.AddRange(list.Select(GetJsTypeName));
}
private void ImportToType(JsClrType ce, List<EntityToJsNode> mappings)
{
foreach (var map in mappings)
{
if (map.JsNode == null)
continue;
var isStatic = map.Entity.IsStatic();
var def = ce.GetDefinition(isStatic);
List<JsJsonNameValue> pairs;
if (map.JsNode is JsNodeList)
pairs = ((JsNodeList)map.JsNode).Nodes.Cast<JsJsonNameValue>().ToList();
else
pairs = new List<JsJsonNameValue> { (JsJsonNameValue)map.JsNode };
foreach (var pair in pairs)
{
if (pair == null)
throw new CompilerException(map.Entity, "Export of entity is null");
var name = pair.Name.Name;
//if (def[name] != pair.Value)
// throw new Exception();
def[name] = pair.Value;
}
}
}
private JsNode ExportClassStructInterface(ITypeDefinition ce)
{
var jsType = new JsClrType();
jsType.Kind = GetJsTypeKind(ce);
jsType.fullname = GetJsTypeName(ce);
var baseClass = GetBaseClassIfValid(ce, true);
if (baseClass != null)
{
var baseClassName = GetJsTypeName(baseClass);
if (baseClassName != jsType.fullname) //avoid object:object inheritance recursion
jsType.baseTypeName = baseClassName;
}
var globalCode = new List<JsUnit>();
if (!ce.IsInterface() || Sk.NewInterfaceImplementation)
{
var members = GetMembersToExport(ce);
var inlineFields = Sk.InlineFields(ce);
var cctor = ce.GetConstructors(false, true).FirstOrDefault();
if (cctor == null && !inlineFields && ce.GetFields().Where(t => t.IsStatic).FirstOrDefault() != null)
{
cctor = CreateStaticCtor(ce);
if (ShouldExportConstructor(cctor))
members.Insert(0, cctor);
}
var mappings = members.Select(t => new EntityToJsNode { JsNode = Visit(t), Entity = t }).ToList();
//Remove GlobalCode=True members from mappings
for (var i = mappings.Count - 1; i >= 0; i--)
{
if (mappings[i].JsNode is JsUnit)
{ //Maybe more clean: Another way could be to check the IEntity for GlobalCode=True
globalCode.Add((JsUnit)mappings[i].JsNode);
mappings.RemoveAt(i);
}
}
ImportToType(jsType, mappings);
}
ExportImplementedInterfaces(ce, jsType);
jsType.assemblyName = AssemblyName;
var atts = ExportCustomAttributes(ce);
if (atts.IsNotNullOrEmpty())
{
if (jsType.customAttributes == null)
jsType.customAttributes = new JsArray<JsClrAttribute>();
jsType.customAttributes.AddRange(atts);
}
var unit = OnAfterExportType(ce, jsType);
globalCode.ForEach(t => unit.Statements.AddRange(t.Statements));
return unit;
}
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;
}
