public IUnitNamespaceReference Map(R.INamespaceSymbol namespaceSymbol) { Contract.Requires(namespaceSymbol != null); Contract.Ensures(Contract.Result<IUnitNamespaceReference>() != null); IUnitNamespaceReference nsr = null; if (!namespaceSymbolCache.TryGetValue(namespaceSymbol, out nsr)) { if (namespaceSymbol.ContainingAssembly.Equals(this.assemblyBeingTranslated)) { var n = this.CreateNamespaceDefinition(namespaceSymbol); return n; } if (namespaceSymbol.IsGlobalNamespace) { var n = new Microsoft.Cci.MutableCodeModel.RootUnitNamespaceReference() { Unit = Map(namespaceSymbol.ContainingAssembly), }; nsr = n; } else { var ns = new Microsoft.Cci.MutableCodeModel.NestedUnitNamespaceReference() { ContainingUnitNamespace = Map(namespaceSymbol.ContainingNamespace), Name = this.nameTable.GetNameFor(namespaceSymbol.Name), }; nsr = ns; } namespaceSymbolCache[namespaceSymbol] = nsr; } Contract.Assume(nsr != null); return nsr; }
public IAssemblyReference Map(R.IAssemblySymbol assembly) { Contract.Requires(assembly != null); Contract.Ensures(Contract.Result<IAssemblyReference>() != null); IAssemblyReference cciAssembly = null; if (!assemblySymbolCache.TryGetValue(assembly, out cciAssembly)) { var an = assembly.Identity; IEnumerable<byte> pkt = an.PublicKeyToken.AsEnumerable(); if (pkt == null) pkt = new byte[0]; var identity = new Microsoft.Cci.AssemblyIdentity( this.nameTable.GetNameFor(an.Name), an.CultureName == null ? "" : an.CultureName, // REVIEW: This can't be right an.Version, pkt, an.Location == null ? "unknown://location" : an.Location ); cciAssembly = new Microsoft.Cci.Immutable.AssemblyReference(this.host, identity); assemblySymbolCache[assembly] = cciAssembly; } Contract.Assume(cciAssembly != null); return cciAssembly; }
/// <summary> /// Creates a nested namespace (because only the root namespace is not nested /// and that is created when the assembly is created). /// Adds it to the namespace cache. /// </summary> /// <param name="namespaceSymbol"></param> /// <returns></returns> private NestedUnitNamespace CreateNamespaceDefinition(R.INamespaceSymbol namespaceSymbol) { var ns = new NestedUnitNamespace() { ContainingUnitNamespace = (IUnitNamespace)this.namespaceSymbolCache[namespaceSymbol.ContainingNamespace], Locations = Helper.WrapLocations(namespaceSymbol.Locations), Name = this.host.NameTable.GetNameFor(namespaceSymbol.Name), //Unit = (IUnit)this.assemblySymbolCache[namespaceSymbol.ContainingAssembly], }; this.namespaceSymbolCache.Add(namespaceSymbol, ns); return ns; }
private PropertyDefinition TranslateMetadata(R.IPropertySymbol propertySymbol) { Contract.Requires(propertySymbol != null); Contract.Ensures(Contract.Result<PropertyDefinition>() != null); var containingType = (ITypeDefinition)this.typeSymbolCache[propertySymbol.ContainingType]; List<IParameterDefinition> parameters = new List<IParameterDefinition>(); var p = new PropertyDefinition() { CallingConvention = propertySymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis, ContainingTypeDefinition = containingType, Getter = propertySymbol.GetMethod == null ? null : this.Map(propertySymbol.GetMethod), Locations = Helper.WrapLocations(propertySymbol.Locations), Name = this.nameTable.GetNameFor(propertySymbol.Name), Parameters = parameters, Setter = propertySymbol.SetMethod == null ? null : this.Map(propertySymbol.SetMethod), Type = this.Map(propertySymbol.Type), Visibility = this.Map(propertySymbol.DeclaredAccessibility), }; //#region Define the parameters //ushort i = 0; //foreach (var p in methodSymbol.Parameters) { // var p_prime = new ParameterDefinition() { // ContainingSignature = p, // Name = nameTable.GetNameFor(p.Name), // Type = this.Map(p.Type), // Index = i++, // }; // parameters.Add(p_prime); //} //#endregion Define the parameters this.propertySymbolCache.Add(propertySymbol, p); return p; }
/// <summary> /// Returns a method whose body is empty, but which can be replaced with the real body when it is /// available. /// </summary> /// <remarks> /// Public because it needs to get called when an anonymous delegate is encountered /// while translating a method body. Just mapping the anonymous delegate doesn't /// provide the information needed. The parameters of a method reference are not /// IParameterDefinitions. /// </remarks> public MethodDefinition TranslateMetadata(R.IMethodSymbol methodSymbol) { Contract.Requires(methodSymbol != null); Contract.Ensures(Contract.Result<MethodDefinition>() != null); var containingType = (ITypeDefinition)this.typeSymbolCache[methodSymbol.ContainingType]; var isConstructor = methodSymbol.MethodKind == R.CommonMethodKind.Constructor; List<IParameterDefinition> parameters = new List<IParameterDefinition>(); var m = new MethodDefinition() { CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis, ContainingTypeDefinition = containingType, InternFactory = this.host.InternFactory, IsHiddenBySignature = true, // REVIEW IsNewSlot = containingType.IsInterface, // REVIEW IsRuntimeSpecial = isConstructor, IsSpecialName = isConstructor, IsStatic = methodSymbol.IsStatic, IsVirtual = containingType.IsInterface, // REVIEW: Why doesn't using methodSymbol.Virtual work for interface methods? Locations = Helper.WrapLocations(methodSymbol.Locations), Name = this.nameTable.GetNameFor(methodSymbol.Name), Parameters = parameters, Type = this.Map(methodSymbol.ReturnType), Visibility = this.Map(methodSymbol.DeclaredAccessibility), }; // IMPORTANT: Have to add it to the cache before doing anything else because it may // get looked up if it is generic and a parameter's type involves the generic // method parameter. this.methodSymbolCache.Add(methodSymbol, m); #region Define the generic parameters if (methodSymbol.IsGenericMethod) { var genericParameters = new List<IGenericMethodParameter>(); foreach (var gp in methodSymbol.TypeParameters) { var gp2 = this.CreateTypeDefinition(gp); genericParameters.Add((IGenericMethodParameter) gp2); } m.GenericParameters = genericParameters; } #endregion #region Define the parameters ushort i = 0; foreach (var p in methodSymbol.Parameters) { var p_prime = new ParameterDefinition() { ContainingSignature = m, IsByReference = p.RefKind == RefKind.Ref, IsIn = p.RefKind == RefKind.None, IsOut = p.RefKind == RefKind.Out, Name = nameTable.GetNameFor(p.Name), Type = this.Map(p.Type), Index = i++, }; parameters.Add(p_prime); } #endregion Define the parameters #region Define default ctor, if needed if (/*methodSymbol.IsSynthesized &&*/ isConstructor) { // BUGBUG!! m.IsHiddenBySignature = true; m.IsRuntimeSpecial = true; m.IsSpecialName = true; var statements = new List<IStatement>(); var body = new SourceMethodBody(this.host, null, null) { LocalsAreZeroed = true, Block = new BlockStatement() { Statements = statements }, }; var thisRef = new ThisReference() { Type = containingType, }; // base(); foreach (var baseClass in containingType.BaseClasses) { var baseCtor = new Microsoft.Cci.MutableCodeModel.MethodReference() { CallingConvention = CallingConvention.HasThis, ContainingType = baseClass, GenericParameterCount = 0, InternFactory = this.host.InternFactory, Name = nameTable.Ctor, Type = this.host.PlatformType.SystemVoid, }; statements.Add( new ExpressionStatement() { Expression = new MethodCall() { MethodToCall = baseCtor, IsStaticCall = false, // REVIEW: Is this needed in addition to setting the ThisArgument? ThisArgument = thisRef, Type = this.host.PlatformType.SystemVoid, // REVIEW: Is this the right way to do this? Arguments = new List<IExpression>(), } } ); break; } // return; statements.Add(new ReturnStatement()); body.MethodDefinition = m; m.Body = body; } #endregion return m; }
private FieldDefinition TranslateMetadata(R.IFieldSymbol fieldSymbol) { Contract.Requires(fieldSymbol != null); Contract.Ensures(Contract.Result<FieldDefinition>() != null); FieldDefinition f = new FieldDefinition() { ContainingTypeDefinition = (ITypeDefinition)this.typeSymbolCache[fieldSymbol.ContainingType], InternFactory = this.host.InternFactory, IsReadOnly = fieldSymbol.IsReadOnly, IsStatic = fieldSymbol.IsStatic, Locations = Helper.WrapLocations(fieldSymbol.Locations), Name = this.nameTable.GetNameFor(fieldSymbol.Name), Type = this.Map(fieldSymbol.Type), Visibility = this.Map(fieldSymbol.DeclaredAccessibility), }; return f; }
public IMethodReference Map(R.IMethodSymbol methodSymbol) { Contract.Requires(methodSymbol != null); IMethodReference mr = null; if (!methodSymbolCache.TryGetValue(methodSymbol, out mr)) { List<IParameterTypeInformation> ps = methodSymbol.Parameters.Count == 0 ? null : new List<IParameterTypeInformation>(); if (methodSymbol.IsGenericMethod && methodSymbol.ConstructedFrom != methodSymbol) { var gArgs = new List<ITypeReference>(); foreach (var a in methodSymbol.TypeArguments){ gArgs.Add(Map(a)); } mr = new Microsoft.Cci.MutableCodeModel.GenericMethodInstanceReference() { CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis, ContainingType = Map(methodSymbol.ContainingType), GenericArguments = gArgs, GenericMethod = Map(methodSymbol.ConstructedFrom), GenericParameterCount = (ushort) methodSymbol.TypeParameters.Count, InternFactory = this.host.InternFactory, Name = this.nameTable.GetNameFor(methodSymbol.Name), Parameters = ps, Type = Map(methodSymbol.ReturnType), }; } else { var m = new Microsoft.Cci.MutableCodeModel.MethodReference(); // IMPORTANT: Have to add it to the cache before doing anything else because it may // get looked up if it is generic and a parameter's type involves the generic // method parameter. this.methodSymbolCache.Add(methodSymbol, m); m.CallingConvention = methodSymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis; m.ContainingType = Map(methodSymbol.ContainingType); m.InternFactory = this.host.InternFactory; m.Name = this.nameTable.GetNameFor(methodSymbol.Name); m.Parameters = ps; m.Type = Map(methodSymbol.ReturnType); mr = m; } foreach (var p in methodSymbol.Parameters) { var p_prime = new ParameterTypeInformation() { ContainingSignature = mr, Index = (ushort)p.Ordinal, Type = Map(p.Type), }; ps.Add(p_prime); } } return mr; }
/// <summary> /// Creates either a generic method parameter or a generic type parameter /// and adds it to the type symbol cache. /// </summary> /// <param name="typeSymbol"></param> /// <returns></returns> private GenericParameter CreateTypeDefinition(R.ITypeParameterSymbol typeSymbol) { Contract.Requires(typeSymbol != null); Contract.Ensures(Contract.Result<GenericParameter>() != null); GenericParameter cciType; var containingSymbol = typeSymbol.ContainingSymbol; if (containingSymbol is R.IMethodSymbol) { cciType = new GenericMethodParameter() { DefiningMethod = (IMethodDefinition)this.Map((R.IMethodSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } else { // assume it is a class parameter? cciType = new GenericTypeParameter() { DefiningType = (ITypeDefinition)this.Map((R.ITypeSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } var constraints = new List<ITypeReference>(); foreach (var c in typeSymbol.ConstraintTypes) { var c2 = this.Map(c); constraints.Add(c2); } cciType.Constraints = constraints; this.typeSymbolCache.Add(typeSymbol, cciType); return cciType; }
private ReferenceMapper(IMetadataHost host, R.IAssemblySymbol assemblySymbol) { this.host = host; this.nameTable = host.NameTable; this.assemblyBeingTranslated = assemblySymbol; }
private NamedTypeDefinition TranslateMetadata(R.INamedTypeSymbol typeSymbol) { Contract.Requires(typeSymbol != null); Contract.Ensures(Contract.Result<NamedTypeDefinition>() != null); NamedTypeDefinition cciType; ITypeReference cciTypeRef; if (this.typeSymbolCache.TryGetValue(typeSymbol, out cciTypeRef)) cciType = (NamedTypeDefinition) cciTypeRef; else cciType = CreateTypeDefinition(typeSymbol); this.module.AllTypes.Add(cciType); var mems = new List<ITypeDefinitionMember>(); foreach (var m in typeSymbol.GetMembers()) { var attributes = this.TranslateMetadata(m.GetAttributes()); switch (m.Kind) { case CommonSymbolKind.Field: var field = TranslateMetadata(m as FieldSymbol); field.Attributes = attributes; if (cciType.Fields == null) cciType.Fields = new List<IFieldDefinition>(); cciType.Fields.Add(field); break; case CommonSymbolKind.Method: var methodSymbol = m as MethodSymbol; var meth = TranslateMetadata(methodSymbol); meth.Attributes = attributes; if (cciType.Methods == null) cciType.Methods = new List<IMethodDefinition>(); cciType.Methods.Add(meth); break; case CommonSymbolKind.NamedType: var namedType = TranslateMetadata((R.INamedTypeSymbol) m); Contract.Assert(namedType is NestedTypeDefinition); var nestedType = (NestedTypeDefinition)namedType; nestedType.Attributes = attributes; if (cciType.NestedTypes == null) cciType.NestedTypes = new List<INestedTypeDefinition>(); cciType.NestedTypes.Add((NestedTypeDefinition)nestedType); break; case CommonSymbolKind.Property: var property = TranslateMetadata(m as PropertySymbol); property.Attributes = attributes; if (cciType.Properties == null) cciType.Properties = new List<IPropertyDefinition>(); cciType.Properties.Add(property); break; default: throw new NotImplementedException(); } } if (typeSymbol.IsValueType) { cciType.Layout = LayoutKind.Sequential; if (IteratorHelper.EnumerableIsEmpty(cciType.Fields)) { cciType.SizeOf = 1; } } return cciType; }
private NestedUnitNamespace TranslateMetadata(R.INamespaceSymbol namespaceSymbol) { Contract.Requires(namespaceSymbol != null); Contract.Ensures(Contract.Result<UnitNamespace>() != null); IUnitNamespaceReference nsr; if (this.namespaceSymbolCache.TryGetValue(namespaceSymbol, out nsr)) { var alreadyTranslatedNamespace = nsr as IUnitNamespace; if (alreadyTranslatedNamespace != null) return alreadyTranslatedNamespace as NestedUnitNamespace; } var ns = CreateNamespaceDefinition(namespaceSymbol); var mems = new List<INamespaceMember>(); foreach (var m in namespaceSymbol.GetMembers()) { var nestedNamespaceSymbol = m as R.INamespaceSymbol; if (nestedNamespaceSymbol != null) { var cciNtd = TranslateMetadata(nestedNamespaceSymbol); mems.Add(cciNtd); } var typeSymbol = m as R.INamedTypeSymbol; if (typeSymbol != null) { var cciType = (INamespaceTypeDefinition)TranslateMetadata(typeSymbol); mems.Add(cciType); continue; } } ns.Members = mems; return ns; }
private Assembly TranslateMetadata(R.IAssemblySymbol assemblySymbol) { Contract.Requires(assemblySymbol != null); Contract.Ensures(Contract.Result<Assembly>() != null); IAssemblyReference cciAssemblyReference = null; Assembly cciAssembly = null; if (assemblySymbolCache.TryGetValue(assemblySymbol, out cciAssemblyReference)) { cciAssembly = cciAssemblyReference as Assembly; System.Diagnostics.Debug.Assert(cciAssembly != null); return cciAssembly; } var coreAssembly = host.LoadAssembly(host.CoreAssemblySymbolicIdentity); var name = assemblySymbol.Identity.Name; var iname = nameTable.GetNameFor(name); cciAssembly = new Assembly() { Attributes = this.TranslateMetadata(assemblySymbol.GetAttributes()), Name = iname, Locations = Helper.WrapLocations(assemblySymbol.Locations), ModuleName = iname, Kind = ModuleKind.DynamicallyLinkedLibrary, RequiresStartupStub = this.host.PointerSize == 4, TargetRuntimeVersion = coreAssembly.TargetRuntimeVersion, Version = assemblySymbol.Identity.Version, }; cciAssembly.AssemblyReferences.Add(coreAssembly); this.assemblySymbolCache.Add(assemblySymbol, cciAssembly); this.module = cciAssembly; var rootUnitNamespace = new RootUnitNamespace(); cciAssembly.UnitNamespaceRoot = rootUnitNamespace; rootUnitNamespace.Unit = cciAssembly; this.namespaceSymbolCache.Add(assemblySymbol.GlobalNamespace, rootUnitNamespace); var moduleClass = new NamespaceTypeDefinition() { ContainingUnitNamespace = rootUnitNamespace, InternFactory = host.InternFactory, IsClass = true, Name = nameTable.GetNameFor("<Module>"), }; cciAssembly.AllTypes.Add(moduleClass); foreach (var m in assemblySymbol.GlobalNamespace.GetMembers()) { var namespaceSymbol = m as NamespaceSymbol; if (namespaceSymbol != null) { var cciNtd = TranslateMetadata(namespaceSymbol); rootUnitNamespace.Members.Add(cciNtd); continue; } var typeSymbol = m as TypeSymbol; if (typeSymbol != null) { var namedType = TranslateMetadata((R.INamedTypeSymbol) typeSymbol); // TODO: fix //namedType.Attributes = TranslateMetadata(typeSymbol.GetAttributes()); var cciType = (INamespaceTypeDefinition) namedType; rootUnitNamespace.Members.Add(cciType); //cciAssembly.AllTypes.Add(cciType); continue; } } //if (this.entryPoint != null) { // cciAssembly.Kind = ModuleKind.ConsoleApplication; // cciAssembly.EntryPoint = this.entryPoint; //} return cciAssembly; }
/// <summary> /// Translates the metadata "backbone" of the Roslyn assembly, creating a CCI /// assembly that is held onto by the returned reference mapper. The mapper /// can be used during a traversal of any syntax tree whose semantic model /// corresponds to the <paramref name="assemblySymbol"/>. The mapper will /// return the equivalent CCI node that corresponds to the semantic node it /// is given. /// </summary> public static ReferenceMapper TranslateAssembly(IMetadataHost host, R.IAssemblySymbol assemblySymbol) { Contract.Requires(host != null); Contract.Requires(assemblySymbol != null); Contract.Ensures(Contract.Result<ReferenceMapper>() != null); var rm = new ReferenceMapper(host, assemblySymbol); rm.TranslateMetadata(assemblySymbol); return rm; }
public static PrimitiveTypeCode GetPrimitiveTypeCode(R.ITypeSymbol type) { Contract.Requires(type != null); Contract.Ensures(Contract.Result<PrimitiveTypeCode>() != PrimitiveTypeCode.Pointer && Contract.Result<PrimitiveTypeCode>() != PrimitiveTypeCode.Reference && Contract.Result<PrimitiveTypeCode>() != PrimitiveTypeCode.Invalid, "These types aren't checked for; all others are."); //if (type.Name == null || String.IsNullOrEmpty(type.Name.Text)) throw new IllFormedSemanticModelException("A CSharpType was found with a null or empty 'Name' field.", type); switch (type.SpecialType) { case Microsoft.CodeAnalysis.SpecialType.System_Boolean: return PrimitiveTypeCode.Boolean; case Microsoft.CodeAnalysis.SpecialType.System_Char: return PrimitiveTypeCode.Char; case Microsoft.CodeAnalysis.SpecialType.System_SByte: return PrimitiveTypeCode.Int8; case Microsoft.CodeAnalysis.SpecialType.System_Single: return PrimitiveTypeCode.Float32; case Microsoft.CodeAnalysis.SpecialType.System_Double: return PrimitiveTypeCode.Float64; case Microsoft.CodeAnalysis.SpecialType.System_Int16: return PrimitiveTypeCode.Int16; case Microsoft.CodeAnalysis.SpecialType.System_Int32: return PrimitiveTypeCode.Int32; case Microsoft.CodeAnalysis.SpecialType.System_Int64: return PrimitiveTypeCode.Int64; case Microsoft.CodeAnalysis.SpecialType.System_IntPtr: return PrimitiveTypeCode.IntPtr; case Microsoft.CodeAnalysis.SpecialType.System_String: return PrimitiveTypeCode.String; case Microsoft.CodeAnalysis.SpecialType.System_Byte: return PrimitiveTypeCode.UInt8; case Microsoft.CodeAnalysis.SpecialType.System_UInt16: return PrimitiveTypeCode.UInt16; case Microsoft.CodeAnalysis.SpecialType.System_UInt32: return PrimitiveTypeCode.UInt32; case Microsoft.CodeAnalysis.SpecialType.System_UInt64: return PrimitiveTypeCode.UInt64; case Microsoft.CodeAnalysis.SpecialType.System_UIntPtr: return PrimitiveTypeCode.UIntPtr; case Microsoft.CodeAnalysis.SpecialType.System_Void: return PrimitiveTypeCode.Void; default: return PrimitiveTypeCode.NotPrimitive; } }
//public PropertyDefinition Map(PropertySymbol propertySymbol) { // PropertyDefinition pd = null; // if (!propertySymbolCache.TryGetValue(propertySymbol, out pd)) { // pd = new PropertyDefinition() { // CallingConvention = propertySymbol.IsStatic ? CallingConvention.Default : CallingConvention.HasThis, // ContainingTypeDefinition = (ITypeDefinition) Map(propertySymbol.ContainingType), // Name = this.nameTable.GetNameFor(propertySymbol.Name), // Type = Map(propertySymbol.Type), // }; // if (propertySymbol.GetMethod != null) { // pd.Getter = Map(propertySymbol.GetMethod); // } // if (propertySymbol.SetMethod != null) { // pd.Setter = Map(propertySymbol.SetMethod); // } // } // return pd; //} public TypeMemberVisibility Map(R.CommonAccessibility a) { switch (a) { case R.CommonAccessibility.Internal: return TypeMemberVisibility.Assembly; case R.CommonAccessibility.NotApplicable: return TypeMemberVisibility.Other; case R.CommonAccessibility.Private: return TypeMemberVisibility.Private; case R.CommonAccessibility.Protected: return TypeMemberVisibility.Family; case R.CommonAccessibility.ProtectedAndInternal: return TypeMemberVisibility.FamilyAndAssembly; //case R.Compilers.CommonAccessibility.ProtectedInternal: // return TypeMemberVisibility.FamilyOrAssembly; case R.CommonAccessibility.Public: return TypeMemberVisibility.Public; default: throw new InvalidDataException("Mapping Accessibility: switch is supposed to be exhaustive."); } }
private ITypeDefinition CreateTypeDefinition(R.ITypeSymbol typeSymbol) { Contract.Requires(typeSymbol != null); var nts = typeSymbol as R.INamedTypeSymbol; if (nts != null) return this.CreateTypeDefinition(nts); var gts = typeSymbol as R.ITypeParameterSymbol; if (gts != null) return this.CreateTypeDefinition(gts); throw new InvalidDataException("CreateTypeDefinition: type case is supposed to be exhaustive."); }
/// <summary> /// Creates the appropriate kind of type definition (nested or not) and /// adds it to the type symbol cache. /// </summary> private NamedTypeDefinition CreateTypeDefinition(R.INamedTypeSymbol typeSymbol) { Contract.Requires(typeSymbol != null); NamedTypeDefinition cciType; if (typeSymbol.ContainingType == null) { cciType = new NamespaceTypeDefinition() { ContainingUnitNamespace = (IUnitNamespace)this.namespaceSymbolCache[typeSymbol.ContainingNamespace], IsPublic = typeSymbol.DeclaredAccessibility == R.CommonAccessibility.Public, }; } else { cciType = new NestedTypeDefinition() { ContainingTypeDefinition = (ITypeDefinition)this.typeSymbolCache[typeSymbol.ContainingType], Visibility = TypeMemberVisibility.Private, }; } if (typeSymbol.TypeKind == R.CommonTypeKind.Interface) { cciType.IsAbstract = true; cciType.IsInterface = true; } else { cciType.BaseClasses = new List<ITypeReference> { this.Map(typeSymbol.BaseType) }; cciType.IsBeforeFieldInit = true; // REVIEW: How to determine from typeSymbol? } cciType.IsClass = typeSymbol.IsReferenceType; cciType.IsValueType = typeSymbol.IsValueType; cciType.IsSealed = typeSymbol.IsSealed; cciType.InternFactory = this.host.InternFactory; cciType.Locations = Helper.WrapLocations(typeSymbol.Locations); cciType.Name = this.host.NameTable.GetNameFor(typeSymbol.Name); this.typeSymbolCache.Add(typeSymbol, cciType); return cciType; }
private CustomAttribute TranslateMetadata(R.CommonAttributeData a) { Contract.Requires(a != null); Contract.Ensures(Contract.Result<CustomAttribute>() != null); var a2 = new CustomAttribute() { Arguments = this.TranslateMetadata(a.ConstructorArguments), Constructor = this.Map(a.AttributeConstructor), NamedArguments = this.TranslateMetadata(a.NamedArguments), }; return a2; }
private IMetadataExpression TranslateMetadata(R.CommonTypedConstant typedConstant) { return new CompileTimeConstant() { Type = this.Map(typedConstant.Type), Value = typedConstant.Value, }; }
public ITypeReference Map(R.ITypeSymbol typeSymbol) { Contract.Requires(typeSymbol != null); Contract.Ensures(Contract.Result<ITypeReference>() != null); ITypeReference itr = null; var arrayType = typeSymbol as R.IArrayTypeSymbol; if (arrayType != null) typeSymbol = arrayType.ElementType; TypeReference tr = null; if (!typeSymbolCache.TryGetValue(typeSymbol, out itr)) { if (this.assemblyBeingTranslated.Equals(typeSymbol.ContainingAssembly)) { // then we have reached this type symbol from a place where it is being referenced, // before its definition has been visited var t = this.CreateTypeDefinition(typeSymbol); return t; } var genericTypeSymbol = typeSymbol as R.ITypeParameterSymbol; if (genericTypeSymbol != null) { var containingSymbol = typeSymbol.ContainingSymbol; if (containingSymbol is R.IMethodSymbol) { tr = new GenericMethodParameterReference() { DefiningMethod = this.Map((R.IMethodSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } else { // assume it is a class parameter? tr = new GenericTypeParameterReference() { DefiningType = this.Map((R.ITypeSymbol)containingSymbol), Name = this.host.NameTable.GetNameFor(typeSymbol.Name), }; } } var namedTypeSymbol = typeSymbol as R.INamedTypeSymbol; // if the symbol and its ConstructedFrom are the same then it is the template if (namedTypeSymbol != null) { if (namedTypeSymbol.IsGenericType && namedTypeSymbol != namedTypeSymbol.ConstructedFrom) { var gas = new List<ITypeReference>(); foreach (var a in namedTypeSymbol.TypeArguments) { gas.Add(this.Map(a)); } var gtr = new Microsoft.Cci.MutableCodeModel.GenericTypeInstanceReference() { GenericArguments = gas, GenericType = (INamedTypeReference)this.Map(namedTypeSymbol.ConstructedFrom), }; tr = gtr; } else { if (typeSymbol.ContainingType == null) { var ntr = new Microsoft.Cci.MutableCodeModel.NamespaceTypeReference() { ContainingUnitNamespace = Map(typeSymbol.ContainingNamespace), GenericParameterCount = (ushort)(namedTypeSymbol == null ? 0 : namedTypeSymbol.TypeParameters.Count), IsValueType = typeSymbol.IsValueType, Name = this.nameTable.GetNameFor(typeSymbol.Name), }; tr = ntr; } else { var nestedTr = new Microsoft.Cci.MutableCodeModel.NestedTypeReference() { ContainingType = Map(typeSymbol.ContainingType), GenericParameterCount = (ushort)namedTypeSymbol.TypeParameters.Count, Name = this.nameTable.GetNameFor(typeSymbol.Name), }; tr = nestedTr; } } } Contract.Assume(tr != null, "Above type tests meant to be exhaustive"); tr.InternFactory = this.host.InternFactory; tr.PlatformType = this.host.PlatformType; tr.TypeCode = GetPrimitiveTypeCode(typeSymbol); this.typeSymbolCache[typeSymbol] = tr; itr = tr; } if (arrayType != null) { itr = (IArrayTypeReference)Microsoft.Cci.Immutable.Vector.GetVector(itr, this.host.InternFactory); } return itr; }