void PType(out TypeNode c) { c = null; TypeNode modifier=null, modified=null; switch (la.kind) { case 6: { Get(); c = SystemTypes.Object; break; } case 7: { Get(); c = SystemTypes.String; break; } case 8: { Get(); c = SystemTypes.Char; break; } case 9: { Get(); c = SystemTypes.Void; break; } case 10: { Get(); c = SystemTypes.Boolean; break; } case 11: { Get(); c = SystemTypes.Int8; break; } case 12: { Get(); c = SystemTypes.Int16; break; } case 13: { Get(); c = SystemTypes.Int32; break; } case 14: { Get(); c = SystemTypes.Int64; break; } case 15: { Get(); c = SystemTypes.UInt8; break; } case 16: { Get(); c = SystemTypes.UInt16; break; } case 17: { Get(); c = SystemTypes.UInt32; break; } case 18: { Get(); c = SystemTypes.UInt64; break; } case 19: { Get(); c = SystemTypes.Single; break; } case 20: { Get(); c = SystemTypes.Double; break; } case 21: { Get(); Expect(22); PType(out modifier); Expect(23); PType(out modified); Expect(24); c = OptionalModifier.For(modifier,modified); break; } case 25: { Get(); Expect(22); string id; Ident(out id); Expect(24); c = LookupTypeParameter(id); break; } case 26: { Get(); Expect(22); string id; Ident(out id); Expect(24); c = LookupMethodTypeParameter(id); break; } case 1: case 28: case 35: { PTypeRef(out c); break; } default: SynErr(109); break; } if (StartOf(1)) { if (la.kind == 27) { Get(); c = c.GetReferenceType(); } else if (la.kind == 28) { Get(); Expect(29); c = c.GetArrayType(1); while (la.kind == 28) { Get(); Expect(29); c = c.GetArrayType(1); } } else if (la.kind == 22) { Get(); PType(out c); while (la.kind == 23) { Get(); PType(out c); } Expect(24); } else { Get(); c = c.GetPointerType(); } } }
public override TypeNode VisitTypeReference(TypeNode type) { //TODO: break up this method if (type == null) { return(null); } TypeNodeList pars = this.pars; TypeNodeList args = this.args; switch (type.NodeType) { case NodeType.ArrayType: ArrayType arrType = (ArrayType)type; TypeNode elemType = this.VisitTypeReference(arrType.ElementType); if (elemType == arrType.ElementType || elemType == null) { return(arrType); } if (arrType.IsSzArray()) { return(elemType.GetArrayType(1)); } return(elemType.GetArrayType(arrType.Rank, arrType.Sizes, arrType.LowerBounds)); case NodeType.DelegateNode: { FunctionType ftype = type as FunctionType; if (ftype == null) { goto default; } TypeNode referringType = ftype.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(ftype.DeclaringType); return(FunctionType.For(this.VisitTypeReference(ftype.ReturnType), this.VisitParameterList(ftype.Parameters), referringType)); } case NodeType.Pointer: Pointer pType = (Pointer)type; elemType = this.VisitTypeReference(pType.ElementType); if (elemType == pType.ElementType || elemType == null) { return(pType); } return(elemType.GetPointerType()); case NodeType.Reference: Reference rType = (Reference)type; elemType = this.VisitTypeReference(rType.ElementType); if (elemType == rType.ElementType || elemType == null) { return(rType); } return(elemType.GetReferenceType()); case NodeType.ArrayTypeExpression: ArrayTypeExpression aExpr = (ArrayTypeExpression)type; aExpr.ElementType = this.VisitTypeReference(aExpr.ElementType); return(aExpr); case NodeType.BoxedTypeExpression: BoxedTypeExpression bExpr = (BoxedTypeExpression)type; bExpr.ElementType = this.VisitTypeReference(bExpr.ElementType); return(bExpr); case NodeType.ClassExpression: { ClassExpression cExpr = (ClassExpression)type; cExpr.Expression = this.VisitTypeExpression(cExpr.Expression); //Could happen if the expression is a template parameter if (cExpr.Expression is Literal lit) { return(lit.Value as TypeNode); } cExpr.TemplateArguments = this.VisitTypeReferenceList(cExpr.TemplateArguments); return(cExpr); } case NodeType.ClassParameter: case NodeType.TypeParameter: int key = type.UniqueKey; for (int i = 0, n = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; i < n && i < m; i++) { //^ assert pars != null && args != null; TypeNode tp = pars[i]; if (tp == null) { continue; } if (tp.UniqueKey == key) { return(args[i]); } if (tp.Name.UniqueIdKey == type.Name.UniqueIdKey && (tp is ClassParameter && type is TypeParameter)) { //This shouldn't really happen, but in practice it does. Hack past it. return(args[i]); } } return(type); case NodeType.FlexArrayTypeExpression: FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type; flExpr.ElementType = this.VisitTypeReference(flExpr.ElementType); return(flExpr); case NodeType.FunctionTypeExpression: FunctionTypeExpression ftExpr = (FunctionTypeExpression)type; ftExpr.Parameters = this.VisitParameterList(ftExpr.Parameters); ftExpr.ReturnType = this.VisitTypeReference(ftExpr.ReturnType); return(ftExpr); case NodeType.InvariantTypeExpression: InvariantTypeExpression invExpr = (InvariantTypeExpression)type; invExpr.ElementType = this.VisitTypeReference(invExpr.ElementType); return(invExpr); case NodeType.InterfaceExpression: InterfaceExpression iExpr = (InterfaceExpression)type; if (iExpr.Expression == null) { goto default; } iExpr.Expression = this.VisitTypeExpression(iExpr.Expression); iExpr.TemplateArguments = this.VisitTypeReferenceList(iExpr.TemplateArguments); return(iExpr); case NodeType.NonEmptyStreamTypeExpression: NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type; neExpr.ElementType = this.VisitTypeReference(neExpr.ElementType); return(neExpr); case NodeType.NonNullTypeExpression: NonNullTypeExpression nnExpr = (NonNullTypeExpression)type; nnExpr.ElementType = this.VisitTypeReference(nnExpr.ElementType); return(nnExpr); case NodeType.NonNullableTypeExpression: NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type; nbExpr.ElementType = this.VisitTypeReference(nbExpr.ElementType); return(nbExpr); case NodeType.NullableTypeExpression: NullableTypeExpression nuExpr = (NullableTypeExpression)type; nuExpr.ElementType = this.VisitTypeReference(nuExpr.ElementType); return(nuExpr); case NodeType.OptionalModifier: { TypeModifier modType = (TypeModifier)type; TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType); TypeNode modifierType = this.VisitTypeReference(modType.Modifier); if (modifiedType == null || modifierType == null) { return(type); } return(OptionalModifier.For(modifierType, modifiedType)); } case NodeType.RequiredModifier: { TypeModifier modType = (TypeModifier)type; TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType); TypeNode modifierType = this.VisitTypeReference(modType.Modifier); if (modifiedType == null || modifierType == null) { Debug.Fail(""); return(type); } return(RequiredModifier.For(modifierType, modifiedType)); } case NodeType.OptionalModifierTypeExpression: OptionalModifierTypeExpression optmodType = (OptionalModifierTypeExpression)type; optmodType.ModifiedType = this.VisitTypeReference(optmodType.ModifiedType); optmodType.Modifier = this.VisitTypeReference(optmodType.Modifier); return(optmodType); case NodeType.RequiredModifierTypeExpression: RequiredModifierTypeExpression reqmodType = (RequiredModifierTypeExpression)type; reqmodType.ModifiedType = this.VisitTypeReference(reqmodType.ModifiedType); reqmodType.Modifier = this.VisitTypeReference(reqmodType.Modifier); return(reqmodType); case NodeType.PointerTypeExpression: PointerTypeExpression pExpr = (PointerTypeExpression)type; pExpr.ElementType = this.VisitTypeReference(pExpr.ElementType); return(pExpr); case NodeType.ReferenceTypeExpression: ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type; rExpr.ElementType = this.VisitTypeReference(rExpr.ElementType); return(rExpr); case NodeType.StreamTypeExpression: StreamTypeExpression sExpr = (StreamTypeExpression)type; sExpr.ElementType = this.VisitTypeReference(sExpr.ElementType); return(sExpr); case NodeType.TupleTypeExpression: TupleTypeExpression tuExpr = (TupleTypeExpression)type; tuExpr.Domains = this.VisitFieldList(tuExpr.Domains); return(tuExpr); case NodeType.TypeExpression: { TypeExpression tExpr = (TypeExpression)type; tExpr.Expression = this.VisitTypeExpression(tExpr.Expression); if (tExpr.Expression is Literal) { return(type); } tExpr.TemplateArguments = this.VisitTypeReferenceList(tExpr.TemplateArguments); return(tExpr); } case NodeType.TypeIntersectionExpression: TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type; tiExpr.Types = this.VisitTypeReferenceList(tiExpr.Types); return(tiExpr); case NodeType.TypeUnionExpression: TypeUnionExpression tyuExpr = (TypeUnionExpression)type; tyuExpr.Types = this.VisitTypeReferenceList(tyuExpr.Types); return(tyuExpr); default: TypeNode declaringType = this.VisitTypeReference(type.DeclaringType); if (declaringType != null) { Identifier tname = type.Name; if (type.Template != null && type.IsGeneric) { tname = type.Template.Name; } TypeNode nt = declaringType.GetNestedType(tname); if (nt != null) { TypeNodeList arguments = type.TemplateArguments; type = nt; if (TargetPlatform.UseGenerics) { if (arguments != null && arguments.Count > 0 && nt.ConsolidatedTemplateParameters != null && nt.ConsolidatedTemplateParameters.Count > 0) { type = nt.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, arguments); } } } } if (type.Template != null && (type.ConsolidatedTemplateParameters == null || type.ConsolidatedTemplateParameters.Count == 0)) { if (!type.IsNotFullySpecialized && (!type.IsNormalized || (this.CurrentType != null && type.DeclaringModule == this.CurrentType.DeclaringModule))) { return(type); } // Type is a template instance, but some of its arguments were themselves parameters. // See if any of these parameters are to be specialized by this specializer. bool mustSpecializeFurther = false; TypeNodeList targs = type.TemplateArguments; int numArgs = targs == null ? 0 : targs.Count; if (targs != null) { targs = new TypeNodeList(targs); for (int i = 0; i < numArgs; i++) { TypeNode targ = targs[i]; if (targ is ITypeParameter tparg) { for (int j = 0, np = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; j < np && j < m; j++) { //^ assert pars != null && args != null; if (TargetPlatform.UseGenerics) { if (!(pars[j] is ITypeParameter par)) { continue; } if (tparg == par || (tparg.ParameterListIndex == par.ParameterListIndex && tparg.DeclaringMember == par.DeclaringMember)) { targ = this.args[j]; break; } } else { if (targ == pars[j]) { targ = this.args[j]; break; } } } } else { if (targ != type) { targ = this.VisitTypeReference(targ); } if (targ == type) { continue; } } mustSpecializeFurther |= targs[i] != targ; targs[i] = targ; } } if (targs == null || !mustSpecializeFurther) { return(type); } return(type.Template.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, targs)); } TypeNodeList tPars = type.TemplateParameters; if (tPars == null || tPars.Count == 0) { return(type); //Not a parameterized type. No need to get an instance. } TypeNodeList tArgs = new TypeNodeList(); for (int i = 0, n = tPars.Count; i < n; i++) { TypeNode tPar = tPars[i]; tArgs.Add(tPar); //Leave parameter in place if there is no match if (tPar == null || tPar.Name == null) { continue; } int idKey = tPar.Name.UniqueIdKey; for (int j = 0, m = pars == null ? 0 : pars.Count, k = args == null ? 0 : args.Count; j < m && j < k; j++) { //^ assert pars != null && args != null; TypeNode par = pars[j]; if (par == null || par.Name == null) { continue; } if (par.Name.UniqueIdKey == idKey) { tArgs[i] = args[j]; break; } } } return(type.GetTemplateInstance(this.TargetModule, this.CurrentType, this.VisitTypeReference(type.DeclaringType), tArgs)); } }
public void Parse_UnsafeCallWithSingleVariableSetSafeByIndexer_ReturnsProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sample = TestHelper.GetSample <IndexerSample>("UnsafeCallWithSingleVariableSetSafeByIndexer", stringTypeNode.GetArrayType(1)); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.True); }
public void Setup(AssemblyNode mscorlib, AssemblyNode jsTypes, AssemblyNode rewriteAssembly) { NumWarnings = 0; NumErrors = 0; MsCorLib = mscorlib; AssemblyDelaySignAttributeType = GetType(mscorlib, "System.Reflection", "AssemblyDelaySignAttribute"); VoidType = GetType(mscorlib, "System", "Void"); ObjectType = GetType(mscorlib, "System", "Object"); StringType = GetType(mscorlib, "System", "String"); IntType = GetType(mscorlib, "System", "Int32"); BooleanType = GetType(mscorlib, "System", "Boolean"); MethodBaseType = GetType(mscorlib, "System.Reflection", "MethodBase"); RuntimeTypeHandleType = GetType(mscorlib, "System", "RuntimeTypeHandle"); NullableTypeConstructor = GetType(mscorlib, "System", "Nullable`1"); CompilerGeneratedAttributeType = GetType (mscorlib, "System.Runtime.CompilerServices", "CompilerGeneratedAttribute"); DllImportAttributeType = GetType(mscorlib, "System.Runtime.InteropServices", "DllImportAttribute"); TypeType = GetType(mscorlib, "System", "Type"); Type_GetMethodMethod = GetMethod(TypeType, "GetMethod", StringType, TypeType.GetArrayType(1)); Type_GetMemberMethod = GetMethod(TypeType, "GetMember", StringType); Type_GetConstructorMethod = GetMethod(TypeType, "GetConstructor", TypeType.GetArrayType(1)); Type_GetTypeFromHandleMethod = GetMethod(TypeType, "GetTypeFromHandle", RuntimeTypeHandleType); Type_GetGenericArgumentsMethod = GetMethod(TypeType, "GetGenericArguments"); Type_MakeArrayTypeMethod = GetMethod(TypeType, "MakeArrayType"); Type_MakeGenericTypeMethod = GetMethod(TypeType, "MakeGenericType", TypeType.GetArrayType(1)); InteropTypes = new InteropTypes(this); InteropManager = new InteropManager(this); IgnoreAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "IgnoreAttribute"); InteropAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "InteropAttribute"); NamingAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NamingAttribute"); ImportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportAttribute"); ImportKeyAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportKeyAttribute"); ExportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ExportAttribute"); NotExportedAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NotExportedAttribute"); InteropGeneratedAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "InteropGeneratedAttribute"); JSTypes = jsTypes; JSContextType = GetType(jsTypes, Constants.JSTypesInteropNS, "JSContext"); InteropContextManagerType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropContextManager"); InteropContextManager_GetDatabaseMethod = GetMethod(InteropContextManagerType, "get_Database"); InteropContextManager_GetCurrentRuntimeMethod = GetMethod(InteropContextManagerType, "get_CurrentRuntime"); InteropContextManager_GetRuntimeForObjectMethod = GetMethod (InteropContextManagerType, "GetRuntimeForObject", ObjectType); InteropDatabaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropDatabase"); InteropDatabase_RegisterRootExpression = GetMethod(InteropDatabaseType, "RegisterRootExpression", StringType); InteropDatabase_RegisterDelegateShimMethod = GetMethod (InteropDatabaseType, "RegisterDelegateShim", TypeType); InteropDatabase_RegisterTypeMethod = GetMethod (InteropDatabaseType, "RegisterType", TypeType, IntType, StringType, StringType, IntType, BooleanType, BooleanType, BooleanType); InteropDatabase_RegisterExportMethod = GetMethod (InteropDatabaseType, "RegisterExport", MethodBaseType, BooleanType, StringType); SimpleMethodBaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodBase"); SimpleMethodInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodInfo"); SimpleMethodInfo_Ctor = GetConstructor (SimpleMethodInfoType, BooleanType, StringType, TypeType, TypeType.GetArrayType(1), TypeType); SimpleConstructorInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleConstructorInfo"); SimpleConstructorInfo_Ctor = GetConstructor(SimpleConstructorInfoType, TypeType, TypeType.GetArrayType(1)); RuntimeType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "Runtime"); Runtime_CompleteConstructionMethod = GetMethod (RuntimeType, "CompleteConstruction", SimpleMethodBaseType, ObjectType, JSContextType); Runtime_CallImportedMethodMethod = GetMethod (RuntimeType, "CallImportedMethod", SimpleMethodBaseType, StringType, ObjectType.GetArrayType(1)); UniversalDelegateType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "UniversalDelegate"); UniversalDelegate_InvokeMethod = GetUniqueMethod(UniversalDelegateType, "Invoke"); MethodBase_GetGenericArgumentsMethod = GetMethod(MethodBaseType, "GetGenericArguments"); ModuleType = GetType(rewriteAssembly, "", "<Module>"); foreach (var member in ModuleType.Members) { var cctor = member as StaticInitializer; if (cctor != null) ModuleCCtorMethod = cctor; } }
public void Parse_SafeCallUsingIndexer_NoProblem() { TypeNode stringTypeNode = IntrospectionUtility.TypeNodeFactory <string>(); Method sample = TestHelper.GetSample <IndexerSample>("SafeCallUsingIndexer", stringTypeNode.GetArrayType(1)); _typeParser.Parse(sample); ProblemCollection result = _typeParser.Problems; Assert.That(TestHelper.ContainsProblemID(c_InjectionCopRuleId, result), Is.False); }
public TypeNode ArrayType(TypeNode type, int rank) { return(type.GetArrayType(rank)); }
private TypeNode/*!*/ ParseArrayOrGenericType(string typeName, TypeNode/*!*/ rootType) { if (typeName == null || rootType == null) { Debug.Assert(false); return rootType; } //Get here after "rootType[" has been parsed. What follows is either an array type specifier or some generic type arguments. if (typeName.Length == 0) throw new InvalidMetadataException(ExceptionStrings.BadSerializedTypeName); //Something ought to follow the [ if (typeName[0] == ']') { //Single dimensional array with zero lower bound if (typeName.Length == 1) return rootType.GetArrayType(1); if (typeName[1] == '[' && typeName.Length > 2) return this.ParseArrayOrGenericType(typeName.Substring(2), rootType.GetArrayType(1)); throw new InvalidMetadataException(ExceptionStrings.BadSerializedTypeName); } if (typeName[0] == '*') { //Single dimensional array with unknown lower bound if (typeName.Length > 1 && typeName[1] == ']') { if (typeName.Length == 2) return rootType.GetArrayType(1, true); if (typeName[2] == '[' && typeName.Length > 3) return this.ParseArrayOrGenericType(typeName.Substring(3), rootType.GetArrayType(1, true)); } throw new InvalidMetadataException(ExceptionStrings.BadSerializedTypeName); } if (typeName[0] == ',') { //Muti dimensional array int rank = 1; while (rank < typeName.Length && typeName[rank] == ',') rank++; if (rank < typeName.Length && typeName[rank] == ']') { if (typeName.Length == rank + 1) return rootType.GetArrayType(rank + 1); if (typeName[rank + 1] == '[' && typeName.Length > rank + 2) return this.ParseArrayOrGenericType(typeName.Substring(rank + 2), rootType.GetArrayType(rank)); } throw new InvalidMetadataException(ExceptionStrings.BadSerializedTypeName); } //Generic type instance int offset = 0; if (typeName[0] == '[') offset = 1; //Assembly qualified type name forming part of a generic parameter list TypeNodeList arguments = new TypeNodeList(); int commaPos = FindFirstCommaOutsideBrackets(typeName); while (commaPos > 1) { arguments.Add(this.GetTypeFromSerializedName(typeName.Substring(offset, commaPos - offset))); typeName = typeName.Substring(commaPos + 1); offset = typeName[0] == '[' ? 1 : 0; commaPos = FindFirstCommaOutsideBrackets(typeName); } //Find the position of the first unbalanced ]. int lastCharPos = offset; for (int leftBracketCount = 0; lastCharPos < typeName.Length; lastCharPos++) { char ch = typeName[lastCharPos]; if (ch == '[') leftBracketCount++; else if (ch == ']') { leftBracketCount--; if (leftBracketCount < 0) break; } } arguments.Add(this.GetTypeFromSerializedName(typeName.Substring(offset, lastCharPos - offset))); TypeNode retVal = rootType.GetGenericTemplateInstance(this.module, arguments); if (lastCharPos + 1 < typeName.Length && typeName[lastCharPos + 1] == ']') lastCharPos++; if (lastCharPos + 1 < typeName.Length) { //The generic type is complete, but there is yet more to the type char ch = typeName[lastCharPos + 1]; if (ch == '+') retVal = this.GetTypeFromSerializedName(typeName.Substring(lastCharPos + 2), retVal); if (ch == '&') retVal = retVal.GetReferenceType(); if (ch == '*') retVal = retVal.GetPointerType(); if (ch == '[') retVal = this.ParseArrayOrGenericType(typeName.Substring(lastCharPos + 2, typeName.Length - 1 - lastCharPos - 1), retVal); } return retVal; }
public void Setup(AssemblyNode mscorlib, AssemblyNode jsTypes, AssemblyNode rewriteAssembly) { NumWarnings = 0; NumErrors = 0; MsCorLib = mscorlib; AssemblyDelaySignAttributeType = GetType(mscorlib, "System.Reflection", "AssemblyDelaySignAttribute"); VoidType = GetType(mscorlib, "System", "Void"); ObjectType = GetType(mscorlib, "System", "Object"); StringType = GetType(mscorlib, "System", "String"); IntType = GetType(mscorlib, "System", "Int32"); BooleanType = GetType(mscorlib, "System", "Boolean"); MethodBaseType = GetType(mscorlib, "System.Reflection", "MethodBase"); RuntimeTypeHandleType = GetType(mscorlib, "System", "RuntimeTypeHandle"); NullableTypeConstructor = GetType(mscorlib, "System", "Nullable`1"); CompilerGeneratedAttributeType = GetType (mscorlib, "System.Runtime.CompilerServices", "CompilerGeneratedAttribute"); DllImportAttributeType = GetType(mscorlib, "System.Runtime.InteropServices", "DllImportAttribute"); TypeType = GetType(mscorlib, "System", "Type"); Type_GetMethodMethod = GetMethod(TypeType, "GetMethod", StringType, TypeType.GetArrayType(1)); Type_GetMemberMethod = GetMethod(TypeType, "GetMember", StringType); Type_GetConstructorMethod = GetMethod(TypeType, "GetConstructor", TypeType.GetArrayType(1)); Type_GetTypeFromHandleMethod = GetMethod(TypeType, "GetTypeFromHandle", RuntimeTypeHandleType); Type_GetGenericArgumentsMethod = GetMethod(TypeType, "GetGenericArguments"); Type_MakeArrayTypeMethod = GetMethod(TypeType, "MakeArrayType"); Type_MakeGenericTypeMethod = GetMethod(TypeType, "MakeGenericType", TypeType.GetArrayType(1)); InteropTypes = new InteropTypes(this); InteropManager = new InteropManager(this); IgnoreAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "IgnoreAttribute"); InteropAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "InteropAttribute"); NamingAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NamingAttribute"); ImportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportAttribute"); ImportKeyAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportKeyAttribute"); ExportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ExportAttribute"); NotExportedAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NotExportedAttribute"); InteropGeneratedAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "InteropGeneratedAttribute"); JSTypes = jsTypes; JSContextType = GetType(jsTypes, Constants.JSTypesInteropNS, "JSContext"); InteropContextManagerType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropContextManager"); InteropContextManager_GetDatabaseMethod = GetMethod(InteropContextManagerType, "get_Database"); InteropContextManager_GetCurrentRuntimeMethod = GetMethod(InteropContextManagerType, "get_CurrentRuntime"); InteropContextManager_GetRuntimeForObjectMethod = GetMethod (InteropContextManagerType, "GetRuntimeForObject", ObjectType); InteropDatabaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropDatabase"); InteropDatabase_RegisterRootExpression = GetMethod(InteropDatabaseType, "RegisterRootExpression", StringType); InteropDatabase_RegisterDelegateShimMethod = GetMethod (InteropDatabaseType, "RegisterDelegateShim", TypeType); InteropDatabase_RegisterTypeMethod = GetMethod (InteropDatabaseType, "RegisterType", TypeType, IntType, StringType, StringType, IntType, BooleanType, BooleanType, BooleanType); InteropDatabase_RegisterExportMethod = GetMethod (InteropDatabaseType, "RegisterExport", MethodBaseType, BooleanType, StringType); SimpleMethodBaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodBase"); SimpleMethodInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodInfo"); SimpleMethodInfo_Ctor = GetConstructor (SimpleMethodInfoType, BooleanType, StringType, TypeType, TypeType.GetArrayType(1), TypeType); SimpleConstructorInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleConstructorInfo"); SimpleConstructorInfo_Ctor = GetConstructor(SimpleConstructorInfoType, TypeType, TypeType.GetArrayType(1)); RuntimeType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "Runtime"); Runtime_CompleteConstructionMethod = GetMethod (RuntimeType, "CompleteConstruction", SimpleMethodBaseType, ObjectType, JSContextType); Runtime_CallImportedMethodMethod = GetMethod (RuntimeType, "CallImportedMethod", SimpleMethodBaseType, StringType, ObjectType.GetArrayType(1)); UniversalDelegateType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "UniversalDelegate"); UniversalDelegate_InvokeMethod = GetUniqueMethod(UniversalDelegateType, "Invoke"); MethodBase_GetGenericArgumentsMethod = GetMethod(MethodBaseType, "GetGenericArguments"); ModuleType = GetType(rewriteAssembly, "", "<Module>"); foreach (var member in ModuleType.Members) { var cctor = member as StaticInitializer; if (cctor != null) { ModuleCCtorMethod = cctor; } } }
public Expression ArrayExpression(ExpressionList expressions, TypeNode arrayElementType) { var clrElementType = arrayElementType; var enumElementType = clrElementType as EnumNode; if (enumElementType != null) clrElementType = enumElementType.UnderlyingType; if (expressions == null) // null; return new Literal(null, arrayElementType.GetArrayType(1)); else { // newarr <expressions.length>; var statements = new StatementList(); statements.Add (new ExpressionStatement (new ConstructArray (arrayElementType, new ExpressionList(new Literal(expressions.Count)), null))); var arrayType = arrayElementType.GetArrayType(1); for (var i = 0; i < expressions.Count; i++) { // dup; // <i>; // <expressions[i]>; // stelem; statements.Add (new AssignmentStatement (new Indexer (new Expression(NodeType.Dup, arrayType), new ExpressionList(new Literal(i)), clrElementType), expressions[i])); } // leave array on stack return new BlockExpression(new Block(statements)); } }