Beispiel #1
0
        public override void Visit(IGenericTypeParameterReference genericTypeParameterReference)
        {
            var definingType = genericTypeParameterReference.DefiningType;
            int index        = genericTypeParameterReference.Index;

            //This index does not account for any inherited generic parameters. See if any containing types contain typeBuilder parameters and adjust the index.
            while (true)
            {
                var nestedType = definingType as INestedTypeReference;
                if (nestedType == null)
                {
                    break;
                }
                definingType = nestedType.ContainingType;
                var genericTypeInstance = definingType as IGenericTypeInstanceReference;
                if (genericTypeInstance != null)
                {
                    index += (int)IteratorHelper.EnumerableCount(genericTypeInstance.GenericArguments);
                }
            }
            //The defining typeBuilder may actually be a containing typeBuilder of the typeBuilder that contains the reference we are mapping here.
            //In that case, the System.Type object obtained below will probably be a different object than the one that would
            //be obtained by looking at the (consolidated) typeBuilder parameter list of the System.Type object that contains the reference.
            //We assume that this does not matter, however, since a Reflection typeBuilder parameter does not keep (visible) track of the typeBuilder which
            //it parameterizes.
            var genericType = this.mapper.GetType(definingType);

            this.result = genericType.GetGenericArguments()[genericTypeParameterReference.Index];
        }
 public override void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     if (Process(genericTypeParameterReference))
     {
         visitor.Visit(genericTypeParameterReference);
     }
     base.Visit(genericTypeParameterReference);
 }
Beispiel #3
0
 public override ITypeReference Rewrite(IGenericTypeParameterReference genericTypeParameterReference)
 {
     if (this.sourceType != null && TypeHelper.TypesAreEquivalent(genericTypeParameterReference.DefiningType, this.sourceType))
     {
         return(this.targetMethodGenericParameters[genericTypeParameterReference.Index]);
     }
     return(genericTypeParameterReference);
 }
Beispiel #4
0
    public override void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference)
    {
        var typ = genericTypeParameterReference.ResolvedType;

        if (typ == Dummy.GenericTypeParameter)
        {
            this.EmitError(genericTypeParameterReference, ErrorCode.GenericTypeParameterResolution);
        }
        else if ((typ.Name != genericTypeParameterReference.Name && !genericTypeParameterReference.Name.Value.StartsWith("!")) || typ.Index != genericTypeParameterReference.Index)
        {
            this.EmitError(genericTypeParameterReference, ErrorCode.GenericTypeParameterResolution);
        }
        base.TraverseChildren(genericTypeParameterReference);
    }
Beispiel #5
0
 public override void Visit(IGenericTypeParameterReference genericTypeParameterReference) {
   var definingType = genericTypeParameterReference.DefiningType;
   int index = genericTypeParameterReference.Index;
   //This index does not account for any inherited generic parameters. See if any containing types contain typeBuilder parameters and adjust the index.
   while (true) {
     var nestedType = definingType as INestedTypeReference;
     if (nestedType == null) break;
     definingType = nestedType.ContainingType;
     var genericTypeInstance = definingType as IGenericTypeInstanceReference;
     if (genericTypeInstance != null) index += (int)IteratorHelper.EnumerableCount(genericTypeInstance.GenericArguments);
   }
   //The defining typeBuilder may actually be a containing typeBuilder of the typeBuilder that contains the reference we are mapping here.
   //In that case, the System.Type object obtained below will probably be a different object than the one that would
   //be obtained by looking at the (consolidated) typeBuilder parameter list of the System.Type object that contains the reference.
   //We assume that this does not matter, however, since a Reflection typeBuilder parameter does not keep (visible) track of the typeBuilder which
   //it parameterizes.
   var genericType = this.mapper.GetType(definingType);
   this.result = genericType.GetGenericArguments()[genericTypeParameterReference.Index];
 }
Beispiel #6
0
 /// <summary>
 /// Rewrites the given generic type parameter reference.
 /// </summary>
 /// <param name="genericTypeParameterReference"></param>
 /// <returns></returns>
 public override ITypeReference Rewrite(IGenericTypeParameterReference genericTypeParameterReference) {
   var result = this.TryMap(genericTypeParameterReference);
   return result ?? base.Rewrite(genericTypeParameterReference);
 }
Beispiel #7
0
 public override void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference)
 {
     MethodEnter(genericTypeParameterReference);
     base.TraverseChildren(genericTypeParameterReference);
     MethodExit();
 }
 public override ITypeReference Rewrite(IGenericTypeParameterReference genericTypeParameterReference)
 {
     return(this.genericArgumentsMap.Find(genericTypeParameterReference.InternedKey) ?? genericTypeParameterReference);
 }
Beispiel #9
0
 public virtual void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
 }
Beispiel #10
0
 /// <summary>
 /// Visit a genericTypeParameterReference. Do not copy if it is a generic type parameter.
 /// </summary>
 public override IGenericTypeParameterReference Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     return(genericTypeParameterReference);
 }
Beispiel #11
0
 public override ITypeReference Rewrite(IGenericTypeParameterReference genericTypeParameterReference) {
   if (this.sourceType != null && TypeHelper.TypesAreEquivalent(genericTypeParameterReference.DefiningType, this.sourceType))
     return this.targetMethodGenericParameters[genericTypeParameterReference.Index];
   return genericTypeParameterReference;
 }
Beispiel #12
0
 /// <summary>
 /// Traverses the generic type parameter reference.
 /// </summary>
 public void Traverse(IGenericTypeParameterReference genericTypeParameterReference)
 {
     Contract.Requires(genericTypeParameterReference != null);
       if (!this.objectsThatHaveAlreadyBeenTraversed.Add(genericTypeParameterReference)) return;
       if (this.preorderVisitor != null) this.preorderVisitor.Visit(genericTypeParameterReference);
       if (this.stopTraversal) return;
       this.TraverseChildren(genericTypeParameterReference);
       if (this.stopTraversal) return;
       if (this.postorderVisitor != null) this.postorderVisitor.Visit(genericTypeParameterReference);
 }
 /// <summary>
 /// Rewrites the given generic type parameter reference.
 /// </summary>
 public virtual ITypeReference Rewrite(IGenericTypeParameterReference genericTypeParameterReference)
 {
     return genericTypeParameterReference;
 }
 public override ITypeReference Rewrite(IGenericTypeParameterReference genericTypeParameterReference)
 {
     if (genericTypeParameterReference.DefiningType.ResolvedType == this.sourceType)
     return this.targetTypeGenericParameters[genericTypeParameterReference.Index];
       return base.Rewrite(genericTypeParameterReference);
 }
Beispiel #15
0
        public override string GetTypeName(ITypeReference type, NameFormattingOptions formattingOptions)
        {
            Contract.Requires(type != null);
            Contract.Ensures(Contract.Result <string>() != null);

            if (type is Dummy)
            {
                return("Microsoft.Cci.DummyTypeReference");
            }
            if ((formattingOptions & NameFormattingOptions.UseTypeKeywords) != 0)
            {
                switch (type.TypeCode)
                {
                case PrimitiveTypeCode.Boolean: return("Boolean");

                case PrimitiveTypeCode.Char: return("Char");

                case PrimitiveTypeCode.Float32: return("Float");

                case PrimitiveTypeCode.Float64: return("Double");

                case PrimitiveTypeCode.Int16: return("Short");

                case PrimitiveTypeCode.Int32: return("Integer");

                case PrimitiveTypeCode.Int64: return("Long");

                case PrimitiveTypeCode.Int8: return("SByte");

                case PrimitiveTypeCode.String: return("String");

                case PrimitiveTypeCode.UInt16: return("UShort");

                case PrimitiveTypeCode.UInt32: return("UInteger");

                case PrimitiveTypeCode.UInt64: return("ULong");

                case PrimitiveTypeCode.UInt8: return("Byte");

                case PrimitiveTypeCode.Void: { Contract.Assert(false); throw new InvalidOperationException(); }

                case PrimitiveTypeCode.NotPrimitive:
                    if (TypeHelper.TypesAreEquivalent(type, type.PlatformType.SystemDecimal))
                    {
                        return("Decimal");
                    }
                    if (TypeHelper.TypesAreEquivalent(type, type.PlatformType.SystemObject))
                    {
                        return("Object");
                    }
                    break;
                }
            }
            IArrayTypeReference /*?*/ arrayType = type as IArrayTypeReference;

            if (arrayType != null)
            {
                return(this.GetArrayTypeName(arrayType, formattingOptions));
            }
            IFunctionPointerTypeReference /*?*/ functionPointerType = type as IFunctionPointerTypeReference;

            if (functionPointerType != null)
            {
                return(this.GetFunctionPointerTypeName(functionPointerType, formattingOptions));
            }
            IGenericTypeParameterReference /*?*/ genericTypeParam = type as IGenericTypeParameterReference;

            if (genericTypeParam != null)
            {
                return(this.GetGenericTypeParameterName(genericTypeParam, formattingOptions));
            }
            IGenericMethodParameterReference /*?*/ genericMethodParam = type as IGenericMethodParameterReference;

            if (genericMethodParam != null)
            {
                return(this.GetGenericMethodParameterName(genericMethodParam, formattingOptions));
            }
            IGenericTypeInstanceReference /*?*/ genericInstance = type as IGenericTypeInstanceReference;

            if (genericInstance != null)
            {
                return(this.GetGenericTypeInstanceName(genericInstance, formattingOptions));
            }
            INestedTypeReference /*?*/ ntTypeDef = type as INestedTypeReference;

            if (ntTypeDef != null)
            {
                return(this.GetNestedTypeName(ntTypeDef, formattingOptions));
            }
            INamespaceTypeReference /*?*/ nsTypeDef = type as INamespaceTypeReference;

            if (nsTypeDef != null)
            {
                return(this.GetNamespaceTypeName(nsTypeDef, formattingOptions));
            }
            IPointerTypeReference /*?*/ pointerType = type as IPointerTypeReference;

            if (pointerType != null)
            {
                return(this.GetPointerTypeName(pointerType, formattingOptions));
            }
            IManagedPointerTypeReference /*?*/ managedPointerType = type as IManagedPointerTypeReference;

            if (managedPointerType != null)
            {
                return(this.GetManagedPointerTypeName(managedPointerType, formattingOptions));
            }
            IModifiedTypeReference /*?*/ modifiedType = type as IModifiedTypeReference;

            if (modifiedType != null)
            {
                return(this.GetModifiedTypeName(modifiedType, formattingOptions));
            }
            if (type.ResolvedType != type && !(type.ResolvedType is Dummy))
            {
                return(this.GetTypeName(type.ResolvedType, formattingOptions));
            }
            return("unknown type: " + type.GetType().ToString());
        }
Beispiel #16
0
 public override void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     allElements.Add(new InvokInfo(Traverser, "IGenericTypeParameterReference", genericTypeParameterReference));
 }
Beispiel #17
0
 /// <summary>
 /// Visit a genericTypeParameterReference. Do not copy if it is a generic type parameter. 
 /// </summary>
 public override IGenericTypeParameterReference Visit(IGenericTypeParameterReference genericTypeParameterReference) {
   return genericTypeParameterReference;
 }
Beispiel #18
0
 //^ ensures this.path.Count == old(this.path.Count);
 /// <summary>
 /// Performs some computation with the given generic type parameter reference.
 /// </summary>
 /// <param name="genericTypeParameterReference"></param>
 public virtual void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
 }
Beispiel #19
0
 public override void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference)
 {
     base.TraverseChildren(genericTypeParameterReference);
 }
 public override void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     if(Process(genericTypeParameterReference)){visitor.Visit(genericTypeParameterReference);}
     base.Visit(genericTypeParameterReference);
 }
Beispiel #21
0
 /// <summary>
 /// Traverses the children of the generic type parameter reference.
 /// </summary>
 public virtual void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference)
 {
     Contract.Requires(genericTypeParameterReference != null);
       this.TraverseChildren((IGenericParameterReference)genericTypeParameterReference);
       if (this.stopTraversal) return;
       this.Traverse(genericTypeParameterReference.DefiningType);
 }
Beispiel #22
0
 public override void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference) {
   base.TraverseChildren(genericTypeParameterReference);
 }
Beispiel #23
0
 public void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     this.traverser.Traverse(genericTypeParameterReference);
 }
Beispiel #24
0
 /// <summary>
 /// Performs some computation with the given generic type parameter reference.
 /// </summary>
 /// <param name="genericTypeParameterReference"></param>
 public virtual void Visit(IGenericTypeParameterReference genericTypeParameterReference)
   //^ ensures this.path.Count == old(this.path.Count);
 {
 }
Beispiel #25
0
 /// <summary>
 /// Performs some computation with the given generic type parameter reference.
 /// </summary>
 public void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     this.Visit((IGenericParameterReference)genericTypeParameterReference);
 }
Beispiel #26
0
 public virtual void onMetadataElement(IGenericTypeParameterReference genericTypeParameterReference)
 {
 }
Beispiel #27
0
        /// <summary>
        /// Use this routine, rather than ITypeReference.Dispatch, to call the appropriate derived overload of an ITypeReference.
        /// The former routine will call Visit(INamespaceTypeDefinition) rather than Visit(INamespaceTypeReference), etc.,
        /// in the case where a definition is used as a reference to itself.
        /// </summary>
        /// <param name="typeReference">A reference to a type definition. Note that a type definition can serve as a reference to itself.</param>
        protected void DispatchAsReference(ITypeReference typeReference)
        {
            INamespaceTypeReference namespaceTypeReference = typeReference.AsNamespaceTypeReference;

            if (namespaceTypeReference != null)
            {
                this.Visit(namespaceTypeReference);
                return;
            }

            IGenericTypeInstanceReference genericTypeInstanceReference = typeReference.AsGenericTypeInstanceReference;

            if (genericTypeInstanceReference != null)
            {
                this.Visit(genericTypeInstanceReference);
                return;
            }

            INestedTypeReference nestedTypeReference = typeReference.AsNestedTypeReference;

            if (nestedTypeReference != null)
            {
                this.Visit(nestedTypeReference);
                return;
            }

            IArrayTypeReference arrayTypeReference = typeReference as IArrayTypeReference;

            if (arrayTypeReference != null)
            {
                this.Visit(arrayTypeReference);
                return;
            }

            IGenericTypeParameterReference genericTypeParameterReference = typeReference.AsGenericTypeParameterReference;

            if (genericTypeParameterReference != null)
            {
                this.Visit(genericTypeParameterReference);
                return;
            }

            IGenericMethodParameterReference genericMethodParameterReference = typeReference.AsGenericMethodParameterReference;

            if (genericMethodParameterReference != null)
            {
                this.Visit(genericMethodParameterReference);
                return;
            }

            IPointerTypeReference pointerTypeReference = typeReference as IPointerTypeReference;

            if (pointerTypeReference != null)
            {
                this.Visit(pointerTypeReference);
                return;
            }

            IModifiedTypeReference modifiedTypeReference = typeReference as IModifiedTypeReference;

            if (modifiedTypeReference != null)
            {
                this.Visit(modifiedTypeReference);
                return;
            }
        }
        public override void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference)
{ MethodEnter(genericTypeParameterReference);
            base.TraverseChildren(genericTypeParameterReference);
     MethodExit();   }
 public virtual void onMetadataElement(IGenericTypeParameterReference genericTypeParameterReference) { }
Beispiel #30
0
 public void Visit(IGenericTypeParameterReference genericTypeParameterReference)
 {
     throw new NotImplementedException();
 }
Beispiel #31
0
        private static void WriteType(ITypeReference type, TextWriter writer, bool omitOutermostTypeFormals)
        {
            Contract.Requires(type != null);
            Contract.Requires(writer != null);

            IArrayType array = type as IArrayType;

            if (array != null)
            {
                Contract.Assume(array.ElementType != null, "lack of CCI2 contracts");

                WriteType(array.ElementType, writer);
                writer.Write("[");
                if (array.Rank > 1)
                {
                    for (int i = 0; i < array.Rank; i++)
                    {
                        if (i > 0)
                        {
                            writer.Write(",");
                        }
                        writer.Write("0:");
                    }
                }
                writer.Write("]");
                return;
            }

            IManagedPointerTypeReference reference = type as IManagedPointerTypeReference;;

            if (reference != null)
            {
                Contract.Assume(reference.TargetType != null, "lack of CCI2 contracts");

                var referencedType = reference.TargetType;
                WriteType(referencedType, writer);
                writer.Write("@");
                return;
            }

            IPointerTypeReference pointer = type as IPointerTypeReference;

            if (pointer != null)
            {
                Contract.Assume(pointer.TargetType != null, "lack of CCI2 contracts");

                WriteType(pointer.TargetType, writer);
                writer.Write("*");
                return;
            }

            IModifiedTypeReference modref = type as IModifiedTypeReference;

            if (modref != null)
            {
                Contract.Assume(modref.UnmodifiedType != null, "lack of CCI2 contracts");
                Contract.Assume(modref.CustomModifiers != null, "lack of CCI2 contracts");

                WriteType(modref.UnmodifiedType, writer);
                foreach (var modifier in modref.CustomModifiers)
                {
                    Contract.Assume(modifier != null, "lack of collection contracts and CCI2 contracts");
                    Contract.Assume(modifier.Modifier != null, "lack of CCI2 contracts");

                    if (modifier.IsOptional)
                    {
                        writer.Write("!");
                    }
                    else
                    {
                        writer.Write("|");
                    }
                    WriteType(modifier.Modifier, writer);
                }
                return;
            }

            IGenericTypeParameterReference gtp = type as IGenericTypeParameterReference;

            if (gtp != null)
            {
                writer.Write("`");
                writer.Write(gtp.Index);
                return;
            }
            IGenericMethodParameterReference gmp = type as IGenericMethodParameterReference;

            if (gmp != null)
            {
                writer.Write("``");
                writer.Write(gmp.Index);
                return;
            }

            IGenericTypeInstanceReference instance = type as IGenericTypeInstanceReference;

            if (instance != null)
            {
                Contract.Assume(instance.GenericType != null, "lack of CCI2 contracts");
                Contract.Assume(instance.GenericArguments != null, "lack of CCI2 contracts");

                WriteType(instance.GenericType, writer, true);
                writer.Write("{");
                var first = true;
                foreach (var arg in instance.GenericArguments)
                {
                    Contract.Assume(arg != null, "lack of collection and CCI2 contracts");

                    if (first)
                    {
                        first = false;
                    }
                    else
                    {
                        writer.Write(",");
                    }
                    WriteType(arg, writer);
                }
                writer.Write("}");
                return;
            }

            // namespace or nested
            INamedTypeReference  named  = (INamedTypeReference)type;
            INestedTypeReference nested = type as INestedTypeReference;

            if (nested != null)
            {
                Contract.Assume(nested.ContainingType != null, "lack of CCI2 contracts");

                // names of nested types begin with outer type name
                WriteType(nested.ContainingType, writer);
                writer.Write(".");
                // continue to write type sig
            }

            INamespaceTypeReference nt = type as INamespaceTypeReference;

            if (nt != null)
            {
                Contract.Assume(nt.ContainingUnitNamespace != null, "lack of CCI2 contracts");

                WriteNamespaceAndSeparator(nt.ContainingUnitNamespace, writer);
                // continue to write type sig
            }
            // name
            writer.Write(named.Name.Value);
            // generic parameters
            if (omitOutermostTypeFormals)
            {
                return;
            }

            if (named.GenericParameterCount > 0)
            {
                writer.Write("`{0}", named.GenericParameterCount);
            }
        }
Beispiel #32
0
 /// <summary>
 /// Traverses the children of the generic type parameter reference.
 /// </summary>
 public virtual void TraverseChildren(IGenericTypeParameterReference genericTypeParameterReference)
 {
     this.TraverseChildren((IGenericParameterReference)genericTypeParameterReference);
       if (this.stopTraversal) return;
       this.Traverse(genericTypeParameterReference.DefiningType);
 }