예제 #1
0
        /// <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);
        }
예제 #2
0
        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);
        }