private static IEnumerable<ITypeReference> AnalyzeNonGenericTypeReference(ITypeReference typeReference)
 {
     if (typeReference is Vector)
         return AnalyzeVectorTypeReference(typeReference);
     else
         return AnalyzeNonVectorTypeReference(typeReference);
 }

		public static string GetName(ITypeReference value)
		{
			if (value != null)
			{
				ITypeCollection genericParameters = value.GenericArguments;
				if (genericParameters.Count > 0)
				{
					using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
					{
						for (int i = 0; i < genericParameters.Count; i++)
						{
							if (i != 0)
							{
								writer.Write(",");
							}

							IType genericParameter = genericParameters[i];
							if (genericParameter != null)
							{
								writer.Write(genericParameter.ToString());
							}
						}

						return value.Name + "<" + writer.ToString() + ">";
					}
				}

				return value.Name;
			}

			throw new NotSupportedException();
		}

 internal ConstantExpression(
   ITypeReference typeReference,
   object/*?*/ value
 ) {
   this.TypeReference = typeReference;
   this.value = value;
 }

		public static ITypeReference Create(ITypeReference elementType)
		{
			if (elementType is IType)
				return new PointerType((IType)elementType);
			else
				return new PointerTypeReference(elementType);
		}

        protected override LocalDefinition DeclareLocalInternal(
            ITypeReference type,
            object identity,
            string name,
            bool isCompilerGenerated,
            LocalSlotConstraints constraints,
            bool isDynamic,
            ImmutableArray<TypedConstant> dynamicTransformFlags)
        {
            if (allLocals == null)
            {
                allLocals = ImmutableArray.CreateBuilder<ILocalDefinition>(1);
            }

            var local = new LocalDefinition(
                identity: identity,
                name: name,
                type: type,
                slot: this.allLocals.Count,
                isCompilerGenerated: isCompilerGenerated,
                constraints: constraints,
                isDynamic: isDynamic,
                dynamicTransformFlags: dynamicTransformFlags);

            this.allLocals.Add(local);
            return local;
        }

		public DefaultUnresolvedAttribute(ITypeReference attributeType, IEnumerable<ITypeReference> constructorParameterTypes)
		{
			if (attributeType == null)
				throw new ArgumentNullException("attributeType");
			this.attributeType = attributeType;
			this.ConstructorParameterTypes.AddRange(constructorParameterTypes);
		}

 private void WriteDefaultOf(ITypeReference type)
 {
     WriteKeyword("default", true);
     WriteSymbol("(");
     WriteTypeName(type, true);
     WriteSymbol(")");
 }

		public SimpleConstantValue(ITypeReference type, object value)
		{
			if (type == null)
				throw new ArgumentNullException("type");
			this.type = type;
			this.value = value;
		}

		string TypeToString(ITypeReference type, ITypeDefinition currentTypeDef = null)
		{
			var builder = CreateBuilder(currentTypeDef);
			IType resolvedType = type.Resolve(ctx);
			AstType node = builder.ConvertType(resolvedType);
			return node.ToString();
		}

 public InstanceCreatorOptions(IUnitReflector reflector, ILocalVariableBindings locals, ITypeReference type, params ITypeReference[] constructorParameters)
 {
     this.type = type;
     this.locals = locals;
     this.reflector = reflector;
     this.constructorParameters = constructorParameters;
 }

		public DefaultAttribute(ITypeReference attributeType, IEnumerable<ITypeReference> constructorParameterTypes)
		{
			if (attributeType == null)
				throw new ArgumentNullException("attributeType");
			this.attributeType = attributeType;
			this.constructorParameterTypes = constructorParameterTypes != null ? constructorParameterTypes.ToArray() : null;
		}

 public ConstantArrayCreation(ITypeReference type, IList<ConstantExpression> arrayElements)
 {
     if (arrayElements == null)
         throw new ArgumentNullException("arrayElements");
     this.elementType = type;
     this.arrayElements = arrayElements;
 }

 public CustomAttribute(
     IMethodReference constructor,
     ITypeReference type,
     ReadOnlyArray<MetadataConstant> positionalArguments) :
     this(constructor, type, positionalArguments, ReadOnlyArray<IMetadataNamedArgument>.Empty)
 {
 }

 public static ITypeReference Unspecialize(ITypeReference type) {
   var sntr = type as ISpecializedNestedTypeReference;
   if (sntr != null) return sntr.UnspecializedVersion;
   var gtir = type as IGenericTypeInstanceReference;
   if (gtir != null) return gtir.GenericType;
   return type;
 }

        private string NameForLocal(int depth, ITypeReference type)
        {
            Contract.Requires(0 <= depth);
            Contract.Requires(type != null);

            var str = String.Format("stack_{0}_{1}", depth, TypeHelper.GetTypeName(type));
            return CleanUpIdentifierName(str);
        }

        private Tuple<int, uint> KeyForLocal(int depth, ITypeReference type)
        {
            Contract.Requires(0 <= depth);
            Contract.Requires(type != null);

            var key = Tuple.Create(depth, type.InternedKey);
            return key;
        }

        public IExpression TypeOf(ITypeReference typeReference)
        {
            var typeOf = new TypeOf();
            typeOf.TypeToGet = typeReference;
            typeOf.Type = reflector.Get<Type>();

            return typeOf;
        }

        public ModifiedTypeReference(ITypeReference modifiedType, ImmutableArray<ICustomModifier> customModifiers)
        {
            Debug.Assert(modifiedType != null);
            Debug.Assert(!customModifiers.IsDefault);

            this.modifiedType = modifiedType;
            this.customModifiers = customModifiers;
        }

        public ModifiedTypeReference(ITypeReference modifiedType, IEnumerable<ICustomModifier> customModifiers)
        {
            Debug.Assert(modifiedType != null);
            Debug.Assert(customModifiers != null);

            this.modifiedType = modifiedType;
            this.customModifiers = customModifiers;
        }

 public bool Matches(ITypeReference typeReference)
 {
     typeReference = TypeHelper.UninstantiateAndUnspecialize(typeReference);
     string name = TypeHelper.GetTypeName(typeReference,
             NameFormattingOptions.TypeParameters );
     _log.Debug("Matching type : " + name+" by " + _identifier.ClassName);
     return _identifier.ClassName == name;
 }