public static string get_type_name(ITypeNode t)
{
if (t is ICommonTypeNode)
{
return (t as ICommonTypeNode).comprehensive_namespace.namespace_name + "." + t.name;
}
else if (t is ICompiledTypeNode)
return (t as ICompiledTypeNode).name;
return t.name;
}
public virtual void visit(ITypeNode value)
{
}
public TypeInfo AddEnum(ITypeNode type, EnumBuilder emb)
{
TypeInfo ti = new TypeInfo(emb);
defs[type] = ti;
return ti;
}
void InvalidateBaseTypeFolderNode(ITypeNode typeNode) {
var btNode = (IBaseTypeFolderNode)typeNode.TreeNode.DataChildren.FirstOrDefault(a => a is IBaseTypeFolderNode);
Debug.Assert(btNode != null || typeNode.TreeNode.Children.Count == 0);
if (btNode != null)
btNode.InvalidateChildren();
}
DeleteTypeDefCommand(ITypeNode[] asmNodes) {
nodes = new DeletableNodes<ITypeNode>(asmNodes);
}
private void ConvertConstantDefinitionNode(IConstantDefinitionNode cnst, string name, ITypeNode type, IConstantNode constant_value)
{
if (constant_value is IArrayConstantNode)
ConvertArrayConstantDef(cnst, name, type, constant_value);
else
if (constant_value is IRecordConstantNode || constant_value is ICompiledStaticMethodCallNodeAsConstant)
ConvertConstantDefWithInitCall(cnst, name, type, constant_value);
else if (constant_value is ICommonNamespaceFunctionCallNodeAsConstant || constant_value is IBasicFunctionCallNodeAsConstant || constant_value is ICommonConstructorCallAsConstant || constant_value is ICompiledStaticFieldReferenceNodeAsConstant)
ConvertSetConstantDef(cnst, name, type, constant_value);
else ConvertSimpleConstant(cnst, name, type, constant_value);
}
private void GenerateArrayInitCode(ILGenerator il, LocalBuilder lb, IArrayInitializer InitalValue, ITypeNode ArrayType)
{
IExpressionNode[] ElementValues = InitalValue.ElementValues;
if (ElementValues[0] is IArrayInitializer)
{
bool is_unsized_array;
Type FieldType, ArrType;
int rank = get_rank(ElementValues[0].type);
TypeInfo ti = helper.GetTypeReference(ElementValues[0].type);
if (NETGeneratorTools.IsBoundedArray(ti))
{
is_unsized_array = false;
ArrType = ti.tp;
FieldType = ti.arr_fld.FieldType;
}
else
{
is_unsized_array = true;
ArrType = helper.GetTypeReference(ElementValues[0].type).tp;
FieldType = ArrType;
}
LocalBuilder llb = il.DeclareLocal(FieldType);
for (int i = 0; i < ElementValues.Length; i++)
{
il.Emit(OpCodes.Ldloc, lb);
PushIntConst(il, i);
if (!is_unsized_array)
{
il.Emit(OpCodes.Ldelem, ArrType);
il.Emit(OpCodes.Ldfld, ti.arr_fld);
}
else
{
//il.Emit(OpCodes.Ldelema, ArrType);
if (rank > 1)
CreateNDimUnsizedArray(il, (ElementValues[i] as IArrayInitializer).type, helper.GetTypeReference((ElementValues[i] as IArrayInitializer).type.element_type), rank, get_sizes(ElementValues[0] as IArrayInitializer, rank), lb.LocalType.GetElementType());
else
CreateUnsizedArray(il, helper.GetTypeReference((ElementValues[i] as IArrayInitializer).type.element_type), (ElementValues[0] as IArrayInitializer).ElementValues.Length, lb.LocalType.GetElementType());
il.Emit(OpCodes.Stelem, ArrType);
il.Emit(OpCodes.Ldloc, lb);
PushIntConst(il, i);
il.Emit(OpCodes.Ldelem, ArrType);
//il.Emit(OpCodes.Ldelem_Ref);
}
il.Emit(OpCodes.Stloc, llb);
if (rank > 1)
GenerateNDimArrayInitCode(il, llb, ElementValues[i] as IArrayInitializer, ElementValues[i].type, rank);
else
GenerateArrayInitCode(il, llb, ElementValues[i] as IArrayInitializer, ArrayType);
}
}
else
if (ElementValues[0] is IRecordConstantNode || ElementValues[0] is IRecordInitializer)
{
TypeInfo ti = helper.GetTypeReference(ElementValues[0].type);
LocalBuilder llb = il.DeclareLocal(ti.tp.MakePointerType());
for (int i = 0; i < ElementValues.Length; i++)
{
il.Emit(OpCodes.Ldloc, lb);
PushIntConst(il, i);
il.Emit(OpCodes.Ldelema, ti.tp);
il.Emit(OpCodes.Stloc, llb);
if (ElementValues[0] is IRecordConstantNode)
GenerateRecordInitCode(il, llb, ElementValues[i] as IRecordConstantNode);
else GenerateRecordInitCode(il, llb, ElementValues[i] as IRecordInitializer, true);
}
}
else
for (int i = 0; i < ElementValues.Length; i++)
{
il.Emit(OpCodes.Ldloc, lb);
PushIntConst(il, i);
ILGenerator ilb = this.il;
TypeInfo ti = helper.GetTypeReference(ElementValues[i].type);
if (ti != null && ti.is_set)
{
this.il = il;
IConstantNode cn1 = null;
IConstantNode cn2 = null;
if (ArrayType != null && ArrayType.element_type.element_type is ICommonTypeNode)
{
cn1 = (ArrayType.element_type.element_type as ICommonTypeNode).lower_value;
cn2 = (ArrayType.element_type.element_type as ICommonTypeNode).upper_value;
}
if (cn1 != null && cn2 != null)
{
cn1.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn1.type).tp);
cn2.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn2.type).tp);
}
else
{
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ldnull);
}
il.Emit(OpCodes.Newobj, ti.def_cnstr);
il.Emit(OpCodes.Stelem_Ref);
il.Emit(OpCodes.Ldloc, lb);
PushIntConst(il, i);
this.il = ilb;
//il.Emit(OpCodes.Ldelem_Ref);
}
if (ti != null && ti.tp.IsValueType && !TypeFactory.IsStandType(ti.tp) && !ti.tp.IsEnum)
il.Emit(OpCodes.Ldelema, ti.tp);
else
if (ti != null && ti.assign_meth != null)
il.Emit(OpCodes.Ldelem_Ref);
this.il = il;
ElementValues[i].visit(this);
if (ti != null && ti.assign_meth != null)
{
il.Emit(OpCodes.Call, ti.assign_meth);
this.il = ilb;
continue;
}
bool box = EmitBox(ElementValues[i], lb.LocalType.GetElementType());
this.il = ilb;
if (ti != null && !box)
NETGeneratorTools.PushStelem(il, ti.tp);
else
il.Emit(OpCodes.Stelem_Ref);
}
}
private void CreateInitCodeForUnsizedArray(ILGenerator il, ITypeNode itn, IExpressionNode arr, LocalBuilder len)
{
ILGenerator tmp_il = this.il;
TypeInfo ti = helper.GetTypeReference(itn);
ICommonTypeNode ictn = itn as ICommonTypeNode;
bool generic_param = (ictn != null && ictn.runtime_initialization_marker != null);
FieldInfo finfo = null;
MethodInfo rif = null;
Label lab = default(Label);
this.il = il;
if (generic_param)
{
finfo = helper.GetField(ictn.runtime_initialization_marker).fi;
lab = il.DefineLabel();
il.Emit(OpCodes.Ldsfld, finfo);
il.Emit(OpCodes.Brfalse, lab);
if (SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction.sym_info is ICompiledMethodNode)
rif = (SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction.sym_info as ICompiledMethodNode).method_info;
else
rif = helper.GetMethod(SystemLibrary.SystemLibInitializer.RuntimeInitializeFunction.sym_info as IFunctionNode).mi;
}
if (ti.tp.IsValueType && ti.init_meth != null || ti.is_arr || ti.is_set || ti.is_typed_file || ti.is_text_file || ti.tp == TypeFactory.StringType ||
(generic_param))
{
LocalBuilder clb = il.DeclareLocal(TypeFactory.Int32Type);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc, clb);
Label tlabel = il.DefineLabel();
Label flabel = il.DefineLabel();
il.MarkLabel(tlabel);
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldloc, len);
il.Emit(OpCodes.Bge, flabel);
if (generic_param)
{
arr.visit(this);
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldsfld, finfo);
}
arr.visit(this);
il.Emit(OpCodes.Ldloc, clb);
if (!ti.is_arr && !ti.is_set && !ti.is_typed_file && !ti.is_text_file)
{
if (generic_param)
{
il.Emit(OpCodes.Ldelem, ti.tp);
il.Emit(OpCodes.Box, ti.tp);
il.EmitCall(OpCodes.Call, rif, null);
il.Emit(OpCodes.Unbox_Any, ti.tp);
il.Emit(OpCodes.Stelem, ti.tp);
}
else if (ti.tp != TypeFactory.StringType)
{
il.Emit(OpCodes.Ldelema, ti.tp);
il.Emit(OpCodes.Call, ti.init_meth);
}
else
{
Label lb1 = il.DefineLabel();
Label lb2 = il.DefineLabel();
il.Emit(OpCodes.Ldelem_Ref);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Beq, lb2);
arr.visit(this);
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldelem_Ref);
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Brfalse, lb1);
il.MarkLabel(lb2);
arr.visit(this);
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Stelem_Ref);
il.MarkLabel(lb1);
}
}
else
{
Label label1 = il.DefineLabel();
il.Emit(OpCodes.Ldelem_Ref);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Brfalse, label1);
arr.visit(this);
il.Emit(OpCodes.Ldloc, clb);
if (ti.is_set)
{
IConstantNode cn1 = (arr.type.element_type as ICommonTypeNode).lower_value;
IConstantNode cn2 = (arr.type.element_type as ICommonTypeNode).upper_value;
if (cn1 != null && cn2 != null)
{
cn1.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn1.type).tp);
cn2.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn2.type).tp);
}
else
{
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ldnull);
}
}
else if (ti.is_typed_file)
{
NETGeneratorTools.PushTypeOf(il, helper.GetTypeReference((arr.type.element_type as ICommonTypeNode).element_type).tp);
}
il.Emit(OpCodes.Newobj, ti.def_cnstr);
il.Emit(OpCodes.Stelem_Ref);
il.MarkLabel(label1);
}
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stloc, clb);
il.Emit(OpCodes.Br, tlabel);
il.MarkLabel(flabel);
}
if (generic_param)
{
il.MarkLabel(lab);
}
this.il = tmp_il;
}
IObjectFieldDescriptor IObjectFieldDescriptor.Type(ITypeNode type)
{
Type(type);
return(this);
}
IDirectiveArgumentDescriptor IDirectiveArgumentDescriptor.Type(
ITypeNode type)
{
Type(type);
return(this);
}
/// <nodoc />
public VariableDeclarationBuilder Type(ITypeNode type)
{
Contract.Requires(type != null);
m_type = type;
return(this);
}
public LetTypeNode(VariableNode v, ITypeNode t)
{
Var = v;
Type = t;
}
public VariableDefinitionNode WithType(ITypeNode type)
{
return(new VariableDefinitionNode(
Location, Variable, type,
DefaultValue));
}
IArgumentDescriptor IArgumentDescriptor.Type(ITypeNode type)
{
TypeReference = TypeReference.GetMoreSpecific(type);
return(this);
}
private void InitializeUnsizedArray(ILGenerator il, TypeInfo ti, ITypeNode _arr_type, IExpressionNode[] exprs, int rank)
{
Type arr_type = helper.GetTypeReference(_arr_type).tp.MakeArrayType();
LocalBuilder tmp = il.DeclareLocal(arr_type);
il.Emit(OpCodes.Stloc, tmp);
for (int i = 2 + rank; i < exprs.Length; i++)
{
il.Emit(OpCodes.Ldloc, tmp);
PushIntConst(il, i - 2 - rank);
ILGenerator ilb = this.il;
if (ti != null && ti.tp.IsValueType && !TypeFactory.IsStandType(ti.tp) && !ti.tp.IsEnum)
il.Emit(OpCodes.Ldelema, ti.tp);
this.il = il;
exprs[i].visit(this);
bool box = EmitBox(exprs[i], arr_type.GetElementType());
this.il = ilb;
TypeInfo ti2 = helper.GetTypeReference(exprs[i].type);
if (ti2 != null && !box)
NETGeneratorTools.PushStelem(il, ti2.tp);
else
il.Emit(OpCodes.Stelem_Ref);
}
il.Emit(OpCodes.Ldloc, tmp);
}
private ICommonFunctionNode GetGenericFunctionContainer(ITypeNode tn)
{
if (tn.common_generic_function_container != null)
{
return tn.common_generic_function_container;
}
if (tn.type_special_kind == type_special_kind.typed_file)
{
return GetGenericFunctionContainer(tn.element_type);
}
if (tn.type_special_kind == type_special_kind.set_type)
{
return GetGenericFunctionContainer(tn.element_type);
}
if (tn.type_special_kind == type_special_kind.array_kind)
{
return GetGenericFunctionContainer(tn.element_type);
}
IRefTypeNode ir = tn as IRefTypeNode;
if (ir != null)
{
return GetGenericFunctionContainer(ir.pointed_type);
}
IGenericTypeInstance igti = tn as IGenericTypeInstance;
if (igti != null)
{
foreach (ITypeNode par in igti.generic_parameters)
{
ICommonFunctionNode rez = GetGenericFunctionContainer(par);
if (rez != null)
{
return rez;
}
}
}
return null;
}
public PropertyNodeCreator(IModuleDocumentNode modNode, ITypeNode ownerNode, PropertyDef property)
{
this.ownerNode = ownerNode;
this.propNode = modNode.Context.DocumentTreeView.Create(property);
}
private void CreateNDimUnsizedArray(ILGenerator il, TypeInfo ti, ITypeNode tn, int rank, IExpressionNode[] sizes)
{
Type arr_type = ti.tp.MakeArrayType(rank);
List<Type> types = new List<Type>();
for (int i = 2; i < rank + 2; i++)
types.Add(TypeFactory.Int32Type);
ConstructorInfo ci = null;
MethodInfo mi = null;
if (tn is ICompiledTypeNode)
ci = arr_type.GetConstructor(types.ToArray());
else
mi = mb.GetArrayMethod(arr_type, ".ctor", CallingConventions.HasThis, null, types.ToArray());
ILGenerator tmp_il = this.il;
this.il = il;
for (int i = 2; i < rank + 2; i++)
sizes[i].visit(this);
this.il = tmp_il;
if (ci != null)
il.Emit(OpCodes.Newobj, ci);
else
il.Emit(OpCodes.Newobj, mi);
}
private bool IsTypeAccessible(ITypeNode type)
{
// type not declared --> treat it as accessible
if (type == null)
{
return(true);
}
// predefined types are always accessible
if (type.IsPredefinedType())
{
return(true);
}
// descend into ParenthesizedType
if (type.Kind == TypeScript.Net.Types.SyntaxKind.ParenthesizedType)
{
return(IsTypeAccessible(type.Cast <IParenthesizedTypeNode>().Type));
}
// an array type is accessible iff its element type is accessible
if (type.Kind == TypeScript.Net.Types.SyntaxKind.ArrayType)
{
return(IsTypeAccessible(type.Cast <IArrayTypeNode>().ElementType));
}
// a union type is accessible iff all its types are accessible
if (type.Kind == TypeScript.Net.Types.SyntaxKind.UnionType)
{
return(type.Cast <IUnionOrIntersectionTypeNode>().Types.All(t => IsTypeAccessible(t)));
}
// a function type is accessible iff its return type and its type parameters are accessible
if (type.Kind == TypeScript.Net.Types.SyntaxKind.FunctionType)
{
var fnType = type.Cast <IFunctionOrConstructorTypeNode>();
var fnParameters = fnType.Parameters ?? NodeArray.Empty <IParameterDeclaration>();
return
(IsTypeAccessible(fnType.Type) &&
fnParameters.All(tp => IsTypeAccessible(tp.Type)));
}
// a type literal is accessible iff all its members are accessible
if (type.Kind == TypeScript.Net.Types.SyntaxKind.TypeLiteral)
{
return(type.Cast <ITypeLiteralNode>().Members.All(m => IsMemberAccessible(m)));
bool IsMemberAccessible(ITypeElement e)
{
var memberTypes = e.Kind == TypeScript.Net.Types.SyntaxKind.PropertySignature
? new[] { e.Cast <IPropertySignature>().Type }
: null; // handle other kinds if needed
return(memberTypes != null && memberTypes.All(t => IsTypeAccessible(t)));
}
}
// if any type argument is inaccessible, this type is not accessible either
var typeArguments = type.GetTypeArguments();
if (!typeArguments.All(t => IsTypeAccessible(t)))
{
return(false);
}
// if this type couldn't be resolved, treat it as inaccessible
var resolvedSymbol = type.ResolvedSymbol;
if (resolvedSymbol == null)
{
return(false);
}
// otherwise, a type is accessible if any of its declarations is either explicitly exported or defined in the prelude
return(resolvedSymbol
.GetDeclarations()
.Any(d =>
d.IsExported() ||
m_semanticModel.TypeChecker.IsPreludeDeclaration(d)));
}
private void add_possible_type_attribute(FieldBuilder fb, ITypeNode type)
{
if (comp_opt.target != TargetType.Dll)
return;
if (type.type_special_kind == type_special_kind.typed_file)
{
Type elem_type = helper.GetTypeReference(type.element_type).tp;
CustomAttributeBuilder cust_bldr = null;
if (type.element_type is ICompiledTypeNode || type.element_type is IRefTypeNode && (type.element_type as IRefTypeNode).pointed_type is ICompiledTypeNode)
cust_bldr = new CustomAttributeBuilder(this.FileOfAttributeConstructor, new object[1] { elem_type });
else
cust_bldr = new CustomAttributeBuilder(this.FileOfAttributeConstructor, new object[1] { elem_type.FullName });
fb.SetCustomAttribute(cust_bldr);
}
else if (type.type_special_kind == type_special_kind.set_type)
{
Type elem_type = helper.GetTypeReference(type.element_type).tp;
CustomAttributeBuilder cust_bldr = null;
if (type.element_type is ICompiledTypeNode || type.element_type is IRefTypeNode && (type.element_type as IRefTypeNode).pointed_type is ICompiledTypeNode)
cust_bldr = new CustomAttributeBuilder(this.SetOfAttributeConstructor, new object[1] { elem_type });
else
cust_bldr = new CustomAttributeBuilder(this.SetOfAttributeConstructor, new object[1] { elem_type.FullName });
fb.SetCustomAttribute(cust_bldr);
}
else if (type.type_special_kind == type_special_kind.short_string)
{
int len = (type as IShortStringTypeNode).Length;
CustomAttributeBuilder cust_bldr = new CustomAttributeBuilder(this.ShortStringAttributeConstructor, new object[1] { len });
fb.SetCustomAttribute(cust_bldr);
}
}
public static ITypeRepresentation ToTypeRepresentation(this ITypeNode typeNode) =>
typeNode switch
{
public void Delete(ITypeNode[] nodes) {
Debug.Assert(infos == null);
if (infos != null)
throw new InvalidOperationException();
infos = new ModelInfo[nodes.Length];
for (int i = 0; i < infos.Length; i++) {
var node = nodes[i];
var info = new ModelInfo(node.TypeDef);
infos[i] = info;
info.OwnerList.RemoveAt(info.Index);
}
}
private void AnalyzeTypeReference([CanBeNull] ITypeNode type)
{
if (type == null || type.IsPredefinedType())
{
return;
}
// Checking for named types like:
// let n: CustomInterface = undefined;
// ~~~~~~~~~~~~~~~
var typeReferenceNode = type.As <ITypeReferenceNode>();
if (typeReferenceNode != null)
{
EntityName entityName = typeReferenceNode.TypeName;
AnalyzeTypeReference(entityName);
AnalyzeTypeArguments(typeReferenceNode.TypeArguments);
}
// Checking for typed literals like:
// let n: {x: number, y: number} = {x: 1, y: 3};
// ~~~~~~~~~~~~~~~~~~~~~~
var typeLiteralNode = type.As <ITypeLiteralNode>();
if (typeLiteralNode != null)
{
// Don't need to register names, because it is not a real interface declaration.
AnalyzeInterfaceMembers(typeLiteralNode.Members, registerPropertyNames: false);
}
// Check for array types like:
// let n: number[] = [1,2];
// ~~~~~~~~
var arrayTypeNode = type.As <IArrayTypeNode>();
if (arrayTypeNode != null)
{
AnalyzeTypeReference(arrayTypeNode.ElementType);
}
// Check for function types like:
// function foo(): () => number {}
// ~~~~~~~~~~~~
var functionType = type.As <IFunctionOrConstructorTypeNode>();
if (functionType != null)
{
AnalyzeParameters(functionType.Parameters);
AnalyzeTypeReference(functionType.Type);
AnalyzeTypeParameters(functionType.TypeParameters);
}
// Check for parenthesized types like:
// function foo(): (() => number)[] {return [];}
// ~~~~~~~~~~~~~~~~
var parenthesizedType = type.As <IParenthesizedTypeNode>();
if (parenthesizedType != null)
{
AnalyzeTypeReference(parenthesizedType.Type);
}
// Checking for union types like:
// type X = string | number;
// ~~~~~~~~~~~~~~~
var unionType = type.As <IUnionTypeNode>();
if (unionType != null)
{
foreach (var t in unionType.Types)
{
AnalyzeTypeReference(t);
}
}
// Checking for tuple types like:
// type X = [1, 2];
// ~~~~~~~~~~~~~~~
var tupleType = type.As <ITupleTypeNode>();
if (tupleType != null)
{
foreach (var t in tupleType.ElementTypes)
{
AnalyzeTypeReference(t);
}
}
// Checking for type query like:
// type X = typeof anIdentifier;
// ~~~~~~~~~~~~~~~
var typeQueryType = type.As <ITypeQueryNode>();
if (typeQueryType != null)
{
var entityName = typeQueryType.ExprName;
AnalyzeTypeReference(entityName);
}
}
CreateNestedTypeDefCommand(ITypeNode ownerType, TypeDefOptions options) {
this.ownerType = ownerType;
var modNode = ownerType.GetModuleNode();
Debug.Assert(modNode != null);
if (modNode == null)
throw new InvalidOperationException();
this.nestedType = ownerType.Create(options.CreateTypeDef(modNode.DnSpyFile.ModuleDef));
}
public ListTypeNode(ITypeNode type)
: this(null, type)
{
}
public Type GetPascalTypeReference(ITypeNode tn)
{
return pas_defs[tn] as Type;
}
public ListTypeNode WithType(ITypeNode type)
{
return(new ListTypeNode(Location, type));
}
//получение типа
public TypeInfo GetTypeReference(ITypeNode type)
{
TypeInfo ti = defs[type] as TypeInfo;
if (ti != null)
{
if (type.type_special_kind == type_special_kind.text_file)
ti.is_text_file = true;
if (!ti.is_set && !ti.is_typed_file && !ti.is_text_file) return ti;
if (ti.clone_meth == null && !ti.is_typed_file && !ti.is_text_file)
{
if (type is ICommonTypeNode)
ti.clone_meth = this.GetMethodBuilder(find_method(type as ICommonTypeNode, "CloneSet"));//ti.tp.GetMethod("Clone");
else
ti.clone_meth = ti.tp.GetMethod("CloneSet");
}
if (ti.def_cnstr == null)
{
//if (type.type_special_kind == type_special_kind.text_file) ti.is_text_file = true;
if (ti.is_set)
{
if (type is ICommonTypeNode)
ti.def_cnstr = this.GetConstructorBuilder(find_constructor_with_params(type as ICommonTypeNode));
else
ti.def_cnstr = find_constructor_with_params(ti.tp);
}
else if (ti.is_typed_file)
{
if (type is ICommonTypeNode)
ti.def_cnstr = this.GetConstructorBuilder(find_constructor_with_one_param(type as ICommonTypeNode));
else
ti.def_cnstr = find_constructor_with_one_param(ti.tp);
}
else
{
if (type is ICommonTypeNode)
ti.def_cnstr = this.GetConstructorBuilder(find_constructor(type as ICommonTypeNode));
else
ti.def_cnstr = find_constructor(ti.tp);
}
}
if (ti.assign_meth == null && !ti.is_typed_file && !ti.is_text_file)
{
if (type is ICommonTypeNode)
ti.assign_meth = this.GetMethodBuilder(find_method(type as ICommonTypeNode, "AssignSetFrom"));
else
ti.assign_meth = ti.tp.GetMethod("AssignSetFrom");
}
return ti;
}
if (type is ICompiledTypeNode) {
ti = new TypeInfo(((ICompiledTypeNode)type).compiled_type);
defs[type] = ti;
return ti;
}
//(ssyy) Ускорил, вставив switch
switch (type.type_special_kind)
{
case type_special_kind.typed_file:
ti = GetTypeReference(type.base_type);
if (ti == null) return null;
ti.is_typed_file = true;
if (ti.def_cnstr == null)
{
if (type.base_type is ICommonTypeNode)
ti.def_cnstr = this.GetConstructorBuilder(find_constructor_with_one_param(type.base_type as ICommonTypeNode));
else
ti.def_cnstr = find_constructor_with_one_param(ti.tp);
}
return ti;
case type_special_kind.set_type:
ti = GetTypeReference(type.base_type);
if (ti == null) return null;
ti.is_set = true;
if (ti.clone_meth == null)
{
if (type.base_type is ICommonTypeNode)
ti.clone_meth = this.GetMethodBuilder(find_method(type.base_type as ICommonTypeNode, "CloneSet"));//ti.tp.GetMethod("Clone");
else
ti.clone_meth = ti.tp.GetMethod("CloneSet");
}
if (ti.assign_meth == null)
{
if (type.base_type is ICommonTypeNode)
ti.assign_meth = this.GetMethodBuilder(find_method(type.base_type as ICommonTypeNode, "AssignSetFrom"));
else
ti.assign_meth = ti.tp.GetMethod("AssignSetFrom");
}
if (ti.def_cnstr == null)
{
if (type.base_type is ICommonTypeNode)
ti.def_cnstr = this.GetConstructorBuilder(find_constructor_with_params(type.base_type as ICommonTypeNode));
else
ti.def_cnstr = find_constructor_with_params(ti.tp);
}
return ti;
case type_special_kind.diap_type:
return GetTypeReference(type.base_type);
case type_special_kind.short_string:
return TypeFactory.string_type;
case type_special_kind.array_kind:
TypeInfo tmp = GetTypeReference(type.element_type);
if (tmp == null) return null;
int rank = (type as ICommonTypeNode).rank;
if (rank == 1)
ti = new TypeInfo(tmp.tp.MakeArrayType());
else
ti = new TypeInfo(tmp.tp.MakeArrayType(rank));
//ti.is_arr = true;
defs[type] = ti;
return ti;
}
if (type is IRefTypeNode) {
TypeInfo ref_ti = GetTypeReference(((IRefTypeNode)type).pointed_type);
if (ref_ti == null) return null;
//(ssyy) Лучше использовать MakePointerType
ti = new TypeInfo(ref_ti.tp.MakePointerType());
defs[type] = ti;
return ti;
}
return null;
}
protected void Type(ITypeNode type)
{
FieldDescription.TypeReference = FieldDescription
.TypeReference.GetMoreSpecific(type);
}
private void InitializeNDimUnsizedArray(ILGenerator il, TypeInfo ti, ITypeNode _arr_type, IExpressionNode[] exprs, int rank)
{
Type arr_type = helper.GetTypeReference(_arr_type).tp.MakeArrayType(rank);
LocalBuilder tmp = il.DeclareLocal(arr_type);
CreateArrayLocalVariable(il, tmp, helper.GetTypeReference((exprs[2 + rank] as IArrayInitializer).type), exprs[2 + rank] as IArrayInitializer, (exprs[2 + rank] as IArrayInitializer).type);
il.Emit(OpCodes.Ldloc, tmp);
}
CreateFieldDefCommand(ITypeNode ownerNode, FieldDefOptions options)
{
this.ownerNode = ownerNode;
this.fieldNode = ownerNode.Create(options.CreateFieldDef(ownerNode.TypeDef.Module));
}
private void CreateInitCodeForUnsizedArray(ILGenerator il, TypeInfo ti, ITypeNode _arr_type, LocalBuilder size)
{
Type arr_type = helper.GetTypeReference(_arr_type).tp.MakeArrayType();
ILGenerator tmp_il = this.il;
this.il = il;
if (ti.tp.IsValueType && ti.init_meth != null || ti.is_arr || ti.is_set || ti.is_typed_file || ti.is_text_file || ti.tp == TypeFactory.StringType)
{
LocalBuilder tmp = il.DeclareLocal(arr_type);
il.Emit(OpCodes.Stloc, tmp);
LocalBuilder clb = il.DeclareLocal(TypeFactory.Int32Type);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc, clb);
Label tlabel = il.DefineLabel();
Label flabel = il.DefineLabel();
il.MarkLabel(tlabel);
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldloc, size);
il.Emit(OpCodes.Bge, flabel);
il.Emit(OpCodes.Ldloc, tmp);
il.Emit(OpCodes.Ldloc, clb);
if (!ti.is_arr && !ti.is_set && !ti.is_typed_file && !ti.is_text_file)
{
if (ti.tp != TypeFactory.StringType)
{
il.Emit(OpCodes.Ldelema, ti.tp);
il.Emit(OpCodes.Call, ti.init_meth);
}
else
{
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Stelem_Ref);
}
}
else
{
Label label1 = il.DefineLabel();
il.Emit(OpCodes.Ldelem_Ref);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Brfalse, label1);
il.Emit(OpCodes.Ldloc, tmp);
il.Emit(OpCodes.Ldloc, clb);
if (ti.is_set)
{
IConstantNode cn1 = (_arr_type as ICommonTypeNode).lower_value;
IConstantNode cn2 = (_arr_type as ICommonTypeNode).upper_value;
if (cn1 != null && cn2 != null)
{
cn1.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn1.type).tp);
cn2.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn2.type).tp);
}
else
{
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ldnull);
}
}
else if (ti.is_typed_file)
{
NETGeneratorTools.PushTypeOf(il, helper.GetTypeReference((_arr_type as ICommonTypeNode).element_type).tp);
}
il.Emit(OpCodes.Newobj, ti.def_cnstr);
il.Emit(OpCodes.Stelem_Ref);
il.MarkLabel(label1);
}
il.Emit(OpCodes.Ldloc, clb);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stloc, clb);
il.Emit(OpCodes.Br, tlabel);
il.MarkLabel(flabel);
il.Emit(OpCodes.Ldloc, tmp);
}
this.il = tmp_il;
}
CreatePropertyDefCommand(ITypeNode ownerNode, PropertyDefOptions options)
{
this.ownerNode = ownerNode;
this.propNode = ownerNode.Create(options.CreatePropertyDef(ownerNode.TypeDef.Module));
}
private void CreateInitCodeForNDimUnsizedArray(ILGenerator il, TypeInfo ti, ITypeNode _arr_type, int rank, IExpressionNode[] exprs)
{
Type arr_type = helper.GetTypeReference(_arr_type).tp.MakeArrayType(rank);
ILGenerator tmp_il = this.il;
this.il = il;
MethodInfo set_meth = null;
MethodInfo addr_meth = null;
MethodInfo get_meth = null;
List<Type> lst2 = new List<Type>();
for (int i = 0; i < exprs.Length; i++)
lst2.Add(TypeFactory.Int32Type);
get_meth = mb.GetArrayMethod(arr_type, "Get", CallingConventions.HasThis, ti.tp, lst2.ToArray());
addr_meth = mb.GetArrayMethod(arr_type, "Address", CallingConventions.HasThis, ti.tp.MakeByRefType(), lst2.ToArray());
lst2.Add(ti.tp);
set_meth = mb.GetArrayMethod(arr_type, "Set", CallingConventions.HasThis, TypeFactory.VoidType, lst2.ToArray());
if (ti.tp.IsValueType && ti.init_meth != null || ti.is_arr || ti.is_set || ti.is_typed_file || ti.is_text_file || ti.tp == TypeFactory.StringType)
{
LocalBuilder tmp = il.DeclareLocal(arr_type);
il.Emit(OpCodes.Stloc, tmp);
List<TmpForNDimArr> lst = new List<TmpForNDimArr>();
for (int i = 0; i < exprs.Length; i++)
{
LocalBuilder clb = il.DeclareLocal(TypeFactory.Int32Type);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stloc, clb);
Label tlabel = il.DefineLabel();
Label flabel = il.DefineLabel();
il.MarkLabel(tlabel);
il.Emit(OpCodes.Ldloc, clb);
TmpForNDimArr tmp_arr_str = new TmpForNDimArr(clb, tlabel, flabel);
lst.Add(tmp_arr_str);
exprs[i].visit(this);
il.Emit(OpCodes.Bge, flabel);
}
il.Emit(OpCodes.Ldloc, tmp);
for (int i = 0; i < exprs.Length; i++)
{
il.Emit(OpCodes.Ldloc, lst[i].clb);
}
if (!ti.is_arr && !ti.is_set && !ti.is_typed_file && !ti.is_text_file)
{
if (ti.tp != TypeFactory.StringType)
{
il.Emit(OpCodes.Call, addr_meth);
il.Emit(OpCodes.Call, ti.init_meth);
}
else
{
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Call, set_meth);
}
}
else
{
Label label1 = il.DefineLabel();
il.Emit(OpCodes.Call, get_meth);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Brfalse, label1);
il.Emit(OpCodes.Ldloc, tmp);
for (int i = 0; i < exprs.Length; i++)
{
il.Emit(OpCodes.Ldloc, lst[i].clb);
}
if (ti.is_set)
{
IConstantNode cn1 = (_arr_type as ICommonTypeNode).lower_value;
IConstantNode cn2 = (_arr_type as ICommonTypeNode).upper_value;
if (cn1 != null && cn2 != null)
{
cn1.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn1.type).tp);
cn2.visit(this);
il.Emit(OpCodes.Box, helper.GetTypeReference(cn2.type).tp);
}
else
{
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ldnull);
}
}
else if (ti.is_typed_file)
{
NETGeneratorTools.PushTypeOf(il, helper.GetTypeReference((_arr_type as ICommonTypeNode).element_type).tp);
}
il.Emit(OpCodes.Newobj, ti.def_cnstr);
il.Emit(OpCodes.Call, set_meth);
il.MarkLabel(label1);
}
for (int i = exprs.Length - 1; i >= 0; i--)
{
il.Emit(OpCodes.Ldloc, lst[i].clb);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Stloc, lst[i].clb);
il.Emit(OpCodes.Br, lst[i].tlabel);
il.MarkLabel(lst[i].flabel);
}
il.Emit(OpCodes.Ldloc, tmp);
}
this.il = tmp_il;
}
public MethodNodeCreator(IModuleFileNode modNode, ITypeNode ownerNode, MethodDef method)
{
this.ownerNode = ownerNode;
this.methodNode = modNode.Context.FileTreeView.Create(method);
}
private void CreateNDimUnsizedArray(ILGenerator il, ITypeNode ArrType, TypeInfo ti, int rank, int[] sizes, Type elem_type)
{
Type arr_type = helper.GetTypeReference(ArrType).tp;
List<Type> types = new List<Type>();
for (int i = 2; i < rank + 2; i++)
types.Add(TypeFactory.Int32Type);
ConstructorInfo ci = null;
MethodInfo mi = null;
if (ArrType is ICompiledTypeNode)
ci = arr_type.GetConstructor(types.ToArray());
else
mi = mb.GetArrayMethod(arr_type, ".ctor", CallingConventions.HasThis, null, types.ToArray());
for (int i = 0; i < sizes.Length; i++)
il.Emit(OpCodes.Ldc_I4, sizes[i]);
if (ci != null)
il.Emit(OpCodes.Newobj, ci);
else
il.Emit(OpCodes.Newobj, mi);
}
public new IInterfaceFieldDescriptor Type(ITypeNode type)
{
base.Type(type);
return(this);
}
private void GenerateNDimArrayInitCode(ILGenerator il, LocalBuilder lb, IArrayInitializer InitalValue, ITypeNode ArrayType, int rank)
{
IExpressionNode[] ElementValues = InitalValue.ElementValues;
Type elem_type = helper.GetTypeReference(ArrayType.element_type).tp;
MethodInfo set_meth = null;
if (ArrayType is ICompiledTypeNode)
set_meth = lb.LocalType.GetMethod("Set");
else
{
List<Type> lst = new List<Type>();
for (int i = 0; i < rank; i++)
lst.Add(TypeFactory.Int32Type);
lst.Add(elem_type);
set_meth = mb.GetArrayMethod(lb.LocalType, "Set", CallingConventions.HasThis, TypeFactory.VoidType, lst.ToArray());
}
List<int> indices = new List<int>();
for (int i = 0; i < ElementValues.Length; i++)
{
if (i == 0)
indices.Add(i);
else
indices[indices.Count - rank] = i;
EmitArrayIndex(il, set_meth, lb, ElementValues[i] as IArrayInitializer, rank - 1, rank, indices);
}
}
/// <summary>
/// Exposes a declaration of the form '@@public export identifier : type = undefined' at the specified (pos, end) location
/// </summary>
/// <remarks>
/// Line map of the source file is not set
/// </remarks>
public static void AddExportToSourceFile(TypeScript.Net.Types.SourceFile sourceFile, string identifier, ITypeNode type, int pos, int end)
{
// A value representing all output directories of the project
var outputDeclaration = new VariableDeclaration(identifier, Identifier.CreateUndefined(), type);
outputDeclaration.Flags |= NodeFlags.Export | NodeFlags.Public | NodeFlags.ScriptPublic;
outputDeclaration.Pos = pos;
outputDeclaration.End = end;
// Final source file looks like
// @@public export outputs: type[] = undefined;
// The 'undefined' part is not really important here. The value at runtime has its own special handling in the resolver.
sourceFile.Statements.Add(new VariableStatement()
{
DeclarationList = new VariableDeclarationList(
NodeFlags.Const,
outputDeclaration)
});
}
private Type get_type_reference_for_pascal_attributes(ITypeNode tn)
{
if (tn.type_special_kind == type_special_kind.short_string)
{
return CreateShortStringType(tn);
}
else if (tn.type_special_kind == type_special_kind.typed_file)
{
return CreateTypedFileType(tn as ICommonTypeNode);
}
else if (tn.type_special_kind == type_special_kind.set_type)
{
return CreateTypedSetType(tn as ICommonTypeNode);
}
else
return helper.GetTypeReference(tn).tp;
}
IInterfaceFieldDescriptor IInterfaceFieldDescriptor.Type(ITypeNode type)
{
Type(type);
return(this);
}
private bool TypeNeedToFix(ITypeNode type)
{
switch (type.type_special_kind)
{
case type_special_kind.array_wrapper:
case type_special_kind.array_kind:
case type_special_kind.set_type:
case type_special_kind.short_string:
case type_special_kind.typed_file:
return true;
}
return false;
}
CreateEventDefCommand(ITypeNode ownerNode, EventDefOptions options)
{
this.ownerNode = ownerNode;
this.eventNode = ownerNode.Create(options.CreateEventDef(ownerNode.TypeDef.Module));
}
private void ConvertSetConstantDef(IConstantDefinitionNode cnst, string name, ITypeNode type, IConstantNode constant_value)
{
TypeInfo ti = helper.GetTypeReference(type);
FieldAttributes attrs = FieldAttributes.Public | FieldAttributes.Static;
if (comp_opt.target == TargetType.Dll)
attrs |= FieldAttributes.InitOnly;
FieldBuilder fb = cur_type.DefineField(name, ti.tp, attrs);
//il.Emit(OpCodes.Newobj, ti.tp.GetConstructor(Type.EmptyTypes));
//il.Emit(OpCodes.Stsfld, fb);
if (cnst != null)
helper.AddConstant(cnst, fb);
bool tmp = save_debug_info;
save_debug_info = false;
constant_value.visit(this);
save_debug_info = tmp;
il.Emit(OpCodes.Stsfld, fb);
if (!ConvertedConstants.ContainsKey(constant_value))
ConvertedConstants.Add(constant_value, fb);
}
public Array(ITypeNode of, int rank)
{
Of = of;
Rank = rank;
}
public void Restore(ITypeNode[] nodes) {
Debug.Assert(infos != null);
if (infos == null)
throw new InvalidOperationException();
Debug.Assert(infos.Length == nodes.Length);
if (infos.Length != nodes.Length)
throw new InvalidOperationException();
for (int i = infos.Length - 1; i >= 0; i--) {
var node = nodes[i];
var info = infos[i];
info.OwnerList.Insert(info.Index, node.TypeDef);
}
infos = null;
}
public new IObjectFieldDescriptor Type(ITypeNode typeNode)
{
base.Type(typeNode);
return(this);
}
CreateTypeDefCommand(IList<TypeDef> ownerList, IFileTreeNodeData ownerNode, TypeDefOptions options) {
this.ownerList = ownerList;
var modNode = ownerNode.GetModuleNode();
Debug.Assert(modNode != null);
if (modNode == null)
throw new InvalidOperationException();
this.nsNodeCreator = new NamespaceNodeCreator(options.Namespace, modNode);
this.typeNode = modNode.Context.FileTreeView.Create(options.CreateTypeDef(modNode.DnSpyFile.ModuleDef));
}
CreateMethodDefCommand(ITypeNode ownerNode, MethodDefOptions options)
{
this.ownerNode = ownerNode;
this.methodNode = ownerNode.Create(options.CreateMethodDef(ownerNode.TypeDef.Module));
}
TypeDefSettingsCommand(ModuleDef module, ITypeNode typeNode, TypeDefOptions options) {
this.module = module;
this.typeNode = typeNode;
this.newOptions = options;
this.origOptions = new TypeDefOptions(typeNode.TypeDef);
this.origParentNode = (IFileTreeNodeData)typeNode.TreeNode.Parent.Data;
this.origParentChildIndex = this.origParentNode.TreeNode.Children.IndexOf(typeNode.TreeNode);
Debug.Assert(this.origParentChildIndex >= 0);
if (this.origParentChildIndex < 0)
throw new InvalidOperationException();
this.nameChanged = origOptions.Name != newOptions.Name;
if (this.origParentNode is INamespaceNode) {
var modNode = (IModuleFileNode)this.origParentNode.TreeNode.Parent.Data;
if (newOptions.Namespace != origOptions.Namespace)
this.nsNodeCreator = new NamespaceNodeCreator(newOptions.Namespace, modNode);
}
if (this.nameChanged || origOptions.Namespace != newOptions.Namespace)
this.typeRefInfos = RefFinder.FindTypeRefsToThisModule(module).Where(a => RefFinder.TypeEqualityComparerInstance.Equals(a, typeNode.TypeDef)).Select(a => new TypeRefInfo(a)).ToArray();
}
public new IArgumentDescriptor Type(
ITypeNode typeNode)
{
base.Type(typeNode);
return(this);
}
public void AddPascalTypeReference(ITypeNode tn, Type t)
{
pas_defs[tn] = t;
}
public FieldDefinitionNode WithType(ITypeNode type)
{
return(new FieldDefinitionNode(
Location, Name, Description,
Arguments, type, Directives));
}
//добавление типа
public TypeInfo AddType(ITypeNode type, TypeBuilder tb)
{
TypeInfo ti = new TypeInfo(tb);
defs[type] = ti;
return ti;
}
public override void VisitTypeNode <T>(GraphContext context, ITypeNode <T> node)
{
base.VisitTypeNode(context, node);
}
public TypeInfo AddExistingType(ITypeNode type, Type t)
{
TypeInfo ti = new TypeInfo(t);
defs[type] = ti;
return ti;
}
private List <ICaseClause> CreateSwitchCasesForTargetFrameworks(NugetAnalyzedPackage analyzedPackage, ITypeNode pkgType)
{
var cases = new List <ICaseClause>();
Contract.Assert(analyzedPackage.TargetFrameworks.Count != 0, "Managed package must have at least one target framework.");
var valid = analyzedPackage.TargetFrameworks.Exists(moniker => m_nugetFrameworkMonikers.FullFrameworkVersionHistory.Contains(moniker) || m_nugetFrameworkMonikers.NetCoreVersionHistory.Contains(moniker));
Contract.Assert(valid, "Target framework monikers must exsist and be registered with internal target framework version helpers.");
var allFullFrameworkDeps = m_nugetFrameworkMonikers.FullFrameworkVersionHistory
.SelectMany(m =>
analyzedPackage.DependenciesPerFramework.TryGetValue(m, out IReadOnlyList <INugetPackage> dependencySpecificFrameworks)
? dependencySpecificFrameworks
: new List <INugetPackage>())
.GroupBy(pkg => pkg.Id)
.Select(grp => grp.OrderBy(pkg => pkg.Version).Last());
foreach (var versionHistory in new List <PathAtom>[] { m_nugetFrameworkMonikers.FullFrameworkVersionHistory, m_nugetFrameworkMonikers.NetCoreVersionHistory })
{
FindAllCompatibleFrameworkMonikers(analyzedPackage, (List <PathAtom> monikers) =>
{
if (monikers.Count == 0)
{
return;
}
if (analyzedPackage.IsNetStandardPackageOnly)
{
cases.AddRange(m_nugetFrameworkMonikers.NetStandardToFullFrameworkCompatibility.Select(m => new CaseClause(new LiteralExpression(m.ToString(m_pathTable.StringTable)))));
}
cases.AddRange(monikers.Take(monikers.Count - 1).Select(m => new CaseClause(new LiteralExpression(m.ToString(m_pathTable.StringTable)))));
var compile = new List <IExpression>();
var runtime = new List <IExpression>();
var dependencies = new List <IExpression>();
// Compile items
if (TryGetValueForFrameworkAndFallbacks(analyzedPackage.References, new NugetTargetFramework(monikers.First()), out IReadOnlyList <RelativePath> refAssemblies))
{
compile.AddRange(refAssemblies.Select(r => CreateSimpleBinary(r)));
}
// Runtime items
if (TryGetValueForFrameworkAndFallbacks(analyzedPackage.Libraries, new NugetTargetFramework(monikers.First()), out IReadOnlyList <RelativePath> libAssemblies))
{
runtime.AddRange(libAssemblies.Select(l => CreateSimpleBinary(l)));
}
// For full framework dependencies we unconditionally include all the distinct dependencies from the nuspec file,
// .NETStandard dependencies are only included if the moniker and the parsed target framework match!
if (m_nugetFrameworkMonikers.IsFullFrameworkMoniker(monikers.First()))
{
dependencies.AddRange(allFullFrameworkDeps.Select(dep => CreateImportFromForDependency(dep)));
}
else
{
if (analyzedPackage.DependenciesPerFramework.TryGetValue(monikers.First(), out IReadOnlyList <INugetPackage> dependencySpecificFrameworks))
{
dependencies.AddRange(dependencySpecificFrameworks.Select(dep => CreateImportFromForDependency(dep)));
}
}
cases.Add(
new CaseClause(
new LiteralExpression(monikers.Last().ToString(m_pathTable.StringTable)),
new ReturnStatement(
Call(
PropertyAccess("Managed", "Factory", "createNugetPackage"),
new LiteralExpression(analyzedPackage.Id),
new LiteralExpression(analyzedPackage.Version),
PropertyAccess("Contents", "all"),
Array(compile),
Array(runtime),
m_nugetFrameworkMonikers.IsFullFrameworkMoniker(monikers.Last())
? Array(dependencies)
: Array(new CallExpression(new Identifier("...addIfLazy"),
new BinaryExpression(
new PropertyAccessExpression("qualifier", "targetFramework"),
SyntaxKind.EqualsEqualsEqualsToken,
new LiteralExpression(monikers.First().ToString(m_pathTable.StringTable))
),
new ArrowFunction(
CollectionUtilities.EmptyArray <IParameterDeclaration>(),
Array(dependencies)
)
))
)
)
)
);
}, versionHistory);
}
return(cases);
}
CreateFieldDefCommand(ITypeNode ownerNode, FieldDefOptions options) {
this.ownerNode = ownerNode;
this.fieldNode = ownerNode.Create(options.CreateFieldDef(ownerNode.TypeDef.Module));
}
private List <ICaseClause> CreateSwitchCasesForTargetFrameworks(NugetAnalyzedPackage analyzedPackage, ITypeNode pkgType)
{
var cases = new List <ICaseClause>();
Contract.Assert(analyzedPackage.TargetFrameworkWithFallbacks.Count != 0, "Managed package must have at least one target framework.");
foreach (var framework in analyzedPackage.TargetFrameworkWithFallbacks)
{
// Emit the fallback cases first:
foreach (var fallback in framework.Value)
{
var fallbackString = fallback.ToString(m_pathTable.StringTable);
cases.Add(new CaseClause(new LiteralExpression(fallbackString)));
}
var compile = new List <IExpression>();
var runtime = new List <IExpression>();
var dependencies = new List <IExpression>();
// Compile items
if (TryGetValueForFrameworkAndFallbacks(analyzedPackage.References, new NugetTargetFramework(framework.Key), out IReadOnlyList <RelativePath> refAssemblies))
{
foreach (var assembly in refAssemblies)
{
compile.Add(CreateSimpleBinary(assembly));
}
}
// Runtime items
if (TryGetValueForFrameworkAndFallbacks(analyzedPackage.Libraries, new NugetTargetFramework(framework.Key), out IReadOnlyList <RelativePath> libAssemblies))
{
foreach (var assembly in libAssemblies)
{
runtime.Add(CreateSimpleBinary(assembly));
}
}
// Dependency items
if (analyzedPackage.DependenciesPerFramework.TryGetValue(
framework.Key,
out IReadOnlyList <INugetPackage> dependencySpecificFrameworks))
{
foreach (var dependencySpecificFramework in dependencySpecificFrameworks)
{
dependencies.Add(CreateImportFromForDependency(dependencySpecificFramework));
}
}
dependencies.AddRange(analyzedPackage.Dependencies.Select(CreateImportFromForDependency));
cases.Add(
new CaseClause(
new LiteralExpression(framework.Key.ToString(m_pathTable.StringTable)),
new ReturnStatement(
new CallExpression(
PropertyAccess("Managed", "Factory", "createNugetPackge"),
new LiteralExpression(analyzedPackage.Id),
new LiteralExpression(analyzedPackage.Version),
PropertyAccess("Contents", "all"),
Array(compile),
Array(runtime),
Array(dependencies)
)
)
)
);
}
return(cases);
}
