public static TypeReference MapDatatype(TypeReference t) { var m = t.MemberOf; var g = t.Container; t = t.Clone() as TypeReference; t.MemberOf = m; t.Container = g; TypeReference retVal = t.Clone() as TypeReference; // Create a type reference var type = s_heuristicData.Datatypes.Find(o => o.MifDatatype == t.Name + (t.Flavor != null ? "." + t.Flavor : "")); if (type == null && !String.IsNullOrEmpty(t.Flavor)) { type = s_heuristicData.Datatypes.Find(o => o.MifDatatype == t.Name); } if (t is TypeParameter) { return(t); } else if (t.Name == null) { retVal.Name = "java.lang.Object"; } else if (type != null) { retVal.Name = type.JavaType; //if (!String.IsNullOrEmpty(type.TemplateParameter)) // retVal.Name = String.Format("{0}.datatypes.generic.{1}", s_apiNs, retVal.Name); //else // retVal.Name = String.Format("{0}.datatypes.{1}", s_apiNs, retVal.Name); retVal.MemberOf = t.MemberOf; retVal.GenericSupplier = t.GenericSupplier; if (t.Name != retVal.Name) { retVal.Flavor = null; // Clear flavors if pointing to a new type } // Default binding information var tParm = type.DefaultBind; if ((t.GenericSupplier == null || t.GenericSupplier.Count == 0) && !String.IsNullOrEmpty(tParm)) { retVal.AddGenericSupplier("def", MapDatatype(new TypeReference() { Name = tParm })); } } // Default member? return(retVal); }
/// <summary> /// Resolves the type reference in the specified module. /// </summary> /// <param name="scope">The module where the type reference is resolved.</param> /// <param name="typeRef">The type reference to resolve.</param> /// <returns>The resolved type definition.</returns> public static TypeDefinition TryResolve(this ModuleDefinition scope, TypeReference typeRef) { var matchingTypeRef = typeRef.Clone(); matchingTypeRef.Scope = scope; return(scope.MetadataResolver.TryResolve(matchingTypeRef)); }
static TypeReference Resolve(TypeReference typeRef, Collection <TypeReference> genTypeContext) { if (!(typeRef is TypeSpecification) && !(typeRef is GenericParameter)) { return(typeRef); } TypeSpecification ret = typeRef.Clone() as TypeSpecification; switch (typeRef.MetadataType) { case MetadataType.RequiredModifier: (ret as RequiredModifierType).ModifierType = Resolve((typeRef as RequiredModifierType).ModifierType, genTypeContext); ret.ElementType = Resolve(ret.ElementType, genTypeContext); break; case MetadataType.OptionalModifier: (ret as OptionalModifierType).ModifierType = Resolve((typeRef as OptionalModifierType).ModifierType, genTypeContext); ret.ElementType = Resolve(ret.ElementType, genTypeContext); break; case MetadataType.Array: case MetadataType.ByReference: case MetadataType.Pinned: case MetadataType.Pointer: ret.ElementType = Resolve(ret.ElementType, genTypeContext); break; case MetadataType.GenericInstance: GenericInstanceType genInst = ret as GenericInstanceType; genInst.GenericArguments.Clear(); foreach (var i in (typeRef as GenericInstanceType).GenericArguments) { genInst.GenericArguments.Add(Resolve(i, genTypeContext)); } ret.ElementType = Resolve(ret.ElementType, genTypeContext); break; case MetadataType.MVar: return(typeRef); case MetadataType.Var: if (genTypeContext == null) { throw new InvalidOperationException(); } return(genTypeContext[(typeRef as GenericParameter).Position]); case MetadataType.FunctionPointer: //not support throw new NotSupportedException(); } return(ret); }
public ConstantTypeRefResolver(TypeReference typeRef) { if (typeRef.MetadataType == MetadataType.Class && !(typeRef is TypeDefinition)) { // TypeRefs from different assemblies get imported as MetadataType.Class // since this information is not stored in the assembly metadata. var typeDef = typeRef.ResolveRequiredType(); typeRef = typeRef.Clone(); typeRef.IsValueType = typeDef.IsValueType; } _typeRef = typeRef; }
TypeReference GetTypeReferenceFromExpression(Expression expr) { if (expr is TypeReferenceExpression) { return((expr as TypeReferenceExpression).TypeReference); } IdentifierExpression ident = expr as IdentifierExpression; if (ident != null) { return(new TypeReference(ident.Identifier, ident.TypeArguments)); } MemberReferenceExpression member = expr as MemberReferenceExpression; if (member != null) { TypeReference targetType = GetTypeReferenceFromExpression(member.TargetObject); if (targetType != null) { if (targetType.GenericTypes.Count == 0 && targetType.IsArrayType == false) { TypeReference tr = targetType.Clone(); tr.Type = tr.Type + "." + member.MemberName; tr.GenericTypes.AddRange(member.TypeArguments); return(tr); } else { return(new InnerClassTypeReference(targetType, member.MemberName, member.TypeArguments)); } } } return(null); }
private TypeReferenceExpression GetTypeReferenceExpression(Expression expr, List <TypeReference> genericTypes) { TypeReferenceExpression tre = expr as TypeReferenceExpression; if (tre != null) { return(new TypeReferenceExpression(new TypeReference(tre.TypeReference.Type, tre.TypeReference.PointerNestingLevel, tre.TypeReference.RankSpecifier, genericTypes))); } StringBuilder b = new StringBuilder(); if (!WriteFullTypeName(b, expr)) { // there is some TypeReferenceExpression hidden in the expression while (expr is FieldReferenceExpression) { expr = ((FieldReferenceExpression)expr).TargetObject; } tre = expr as TypeReferenceExpression; if (tre != null) { TypeReference typeRef = tre.TypeReference; if (typeRef.GenericTypes.Count == 0) { typeRef = typeRef.Clone(); typeRef.Type += "." + b.ToString(); typeRef.GenericTypes.AddRange(genericTypes); } else { typeRef = new InnerClassTypeReference(typeRef, b.ToString(), genericTypes); } return(new TypeReferenceExpression(typeRef)); } } return(new TypeReferenceExpression(new TypeReference(b.ToString(), 0, null, genericTypes))); }
public virtual Differences VisitTypeReference(TypeReference reference1, TypeReference reference2){ Differences differences = new Differences(reference1, reference2); if (reference1 == null || reference2 == null){ if (reference1 != reference2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++; return differences; } UnaryExpression changes = (UnaryExpression)reference2.Clone(); UnaryExpression deletions = (UnaryExpression)reference2.Clone(); UnaryExpression insertions = (UnaryExpression)reference2.Clone(); Differences diff = this.VisitTypeNode(reference1.Type, reference2.Type); if (diff == null){Debug.Assert(false); return differences;} changes.Type = diff.Changes as TypeNode; deletions.Type = diff.Deletions as TypeNode; insertions.Type = diff.Insertions as TypeNode; //Debug.Assert(diff.Changes == changes.Type && diff.Deletions == deletions.Type && diff.Insertions == insertions.Type); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; if (differences.NumberOfDifferences == 0){ differences.Changes = null; differences.Deletions = null; differences.Insertions = null; }else{ differences.Changes = changes; differences.Deletions = deletions; differences.Insertions = insertions; } return differences; }
public static TypeReference MapDatatype(TypeReference t) { var m = t.MemberOf; var g = t.Container; TypeReference retVal = t.Clone() as TypeReference; retVal.MemberOf = m; retVal.Container = g; if (t is TypeParameter) { return(t); } else if (t.Name == null) { retVal.Name = "System.Object"; } else if (flavMaps.ContainsKey(t.Name + "." + t.Flavor)) { // Create a type reference Type type = flavMaps[t.Name + "." + t.Flavor]; retVal.Name = type.Name; if (type.IsInterface) { retVal.Name = type.FullName; } if (retVal.Name.Contains("`")) { retVal.Name = retVal.Name.Substring(0, retVal.Name.IndexOf("`")); } retVal.MemberOf = t.MemberOf; retVal.GenericSupplier = t.GenericSupplier; if (t.Name != retVal.Name) { retVal.Flavor = null; // Clear flavors if pointing to a new type } } else if (typeMaps.ContainsKey(String.Format("{0}#{1}", t.Name, t.GenericSupplier != null && t.GenericSupplier.Count > 0 ? t.GenericSupplier[0].Name : null))) // Maps types { Type type = typeMaps[String.Format("{0}#{1}", t.Name, t.GenericSupplier != null && t.GenericSupplier.Count > 0 ? t.GenericSupplier[0].Name : null)]; retVal.Name = type.Name; if (type.IsInterface) { retVal.Name = type.FullName; } if (retVal.Name.Contains("`")) { retVal.Name = retVal.Name.Substring(0, retVal.Name.IndexOf("`")); } retVal.MemberOf = t.MemberOf; if (type.IsGenericTypeDefinition) { retVal.GenericSupplier = t.GenericSupplier; } else { retVal.GenericSupplier = null; } } else if (typeMaps.ContainsKey(String.Format("{0}#", t.Name))) // Maps types { Type type = typeMaps[String.Format("{0}#", t.Name)]; retVal.Name = type.Name; if (type.IsInterface) { retVal.Name = type.FullName; } if (retVal.Name.Contains("`")) { retVal.Name = retVal.Name.Substring(0, retVal.Name.IndexOf("`")); } retVal.MemberOf = t.MemberOf; retVal.GenericSupplier = t.GenericSupplier; } // Type parm info var tParm = defaultTypeParms.Find(o => o.StructureAttribute.Name.Equals(t.Name)); if (tParm != null && (t.GenericSupplier == null || t.GenericSupplier.Count == 0) && tParm.DefaultTypeParameter != null) { // Create the type parm var staParm = tParm.DefaultTypeParameter.GetCustomAttributes(typeof(StructureAttribute), false); for (int i = 0; i < tParm.Type.GetGenericArguments().Length; i++) { if (staParm.Length > 0) { retVal.AddGenericSupplier(i.ToString(), MapDatatype(new TypeReference() { Name = (staParm[0] as StructureAttribute).Name })); } else { retVal.AddGenericSupplier(i.ToString(), new TypeReference() { Name = tParm.DefaultTypeParameter.FullName }); } } } // Default member? return(retVal); }