Rename ConstructedType to ParameterizedType.

ICSharpCode.NRefactory.Tests/TypeSystem/CecilLoaderTests.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			ITypeDefinition c = Mscorlib.GetClass(typeof(Comparer<>));
 			IProperty def = c.Properties.Single(p => p.Name == "Default");
-			ConstructedType pt = (ConstructedType)def.ReturnType.Resolve(ctx);
+			ParameterizedType pt = (ParameterizedType)def.ReturnType.Resolve(ctx);
 			Assert.AreEqual("System.Collections.Generic.Comparer", pt.FullName);
 			Assert.AreSame(c.TypeParameters[0], pt.TypeArguments[0]);
 		}

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -81,11 +81,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Assert.AreEqual(42, (int)typeTest.PositionalArguments[0].GetValue(ctx));
 			// second argument is typeof(System.Action<>)
 			IType rt = (IType)typeTest.PositionalArguments[1].GetValue(ctx);
-			Assert.IsFalse(rt is ConstructedType); // rt must not be constructed - it's just an unbound type
+			Assert.IsFalse(rt is ParameterizedType); // rt must not be constructed - it's just an unbound type
 			Assert.AreEqual("System.Action", rt.FullName);
 			Assert.AreEqual(1, rt.TypeParameterCount);
 			// third argument is typeof(IDictionary<string, IList<TestAttribute>>)
-			ConstructedType crt = (ConstructedType)typeTest.PositionalArguments[2].GetValue(ctx);
+			ParameterizedType crt = (ParameterizedType)typeTest.PositionalArguments[2].GetValue(ctx);
 			Assert.AreEqual("System.Collections.Generic.IDictionary", crt.FullName);
 			Assert.AreEqual("System.String", crt.TypeArguments[0].FullName);
 			// ? for NUnit.TestAttribute (because that assembly isn't in ctx)

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -146,7 +146,6 @@
     <Compile Include="TypeSystem\ByReferenceType.cs" />
     <Compile Include="TypeSystem\CecilLoader.cs" />
     <Compile Include="TypeSystem\ClassType.cs" />
-    <Compile Include="TypeSystem\ConstructedType.cs" />
     <Compile Include="TypeSystem\DomRegion.cs" />
     <Compile Include="TypeSystem\EntityType.cs" />
     <Compile Include="TypeSystem\ExtensionMethods.cs" />
@@ -196,6 +195,7 @@
     <Compile Include="TypeSystem\ITypeParameter.cs" />
     <Compile Include="TypeSystem\ITypeReference.cs" />
     <Compile Include="TypeSystem\ITypeResolveContext.cs" />
+    <Compile Include="TypeSystem\ParameterizedType.cs" />
     <Compile Include="TypeSystem\TypeVisitor.cs" />
     <Compile Include="TypeSystem\IVariable.cs" />
     <Compile Include="TypeSystem\PointerType.cs" />

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -200,7 +200,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					typeIndex++;
 					para[i] = CreateType(gType.GenericArguments[i], entity, typeAttributes, ref typeIndex);
 				}
-				return ConstructedTypeReference.Create(baseType, para);
+				return ParameterizedTypeReference.Create(baseType, para);
 			} else if (type is GenericParameter) {
 				GenericParameter typeGP = type as GenericParameter;
 				if (typeGP.Owner is MethodDefinition) {

ICSharpCode.NRefactory/TypeSystem/IType.cs

@@ -65,7 +65,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets inner classes (including inherited inner classes).
 		/// </summary>
 		/// <remarks>
-		/// If the inner class is generic, this method produces <see cref="ConstructedType"/>s that
+		/// If the inner class is generic, this method produces <see cref="ParameterizedType"/>s that
 		/// parameterize each nested class with its own type parameters.
 		/// </remarks>
 		/// <returns>A new mutable list</returns>

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs

@@ -376,7 +376,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 					foreach (ITypeDefinition innerClass in this.InnerClasses) {
 						if (innerClass.TypeParameterCount > 0) {
 							// Parameterize inner classes with their own type parameters, as per <remarks> on IType.GetNestedTypes.
-							nestedTypes.Add(new ConstructedType(innerClass, innerClass.TypeParameters));
+							nestedTypes.Add(new ParameterizedType(innerClass, innerClass.TypeParameters));
 						} else {
 							nestedTypes.Add(innerClass);
 						}

ICSharpCode.NRefactory/TypeSystem/ParameterizedType.cs

@@ -13,7 +13,7 @@ using ICSharpCode.NRefactory.TypeSystem.Implementation;
 namespace ICSharpCode.NRefactory.TypeSystem
 {
 	/// <summary>
-	/// ConstructedType represents an instance of a generic type.
+	/// ParameterizedType represents an instance of a generic type.
 	/// Example: List&lt;string&gt;
 	/// </summary>
 	/// <remarks>
@@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 	/// <see cref="GenericReturnType"/>s are replaced with the return types in the
 	/// type arguments collection.
 	/// </remarks>
-	public sealed class ConstructedType : Immutable, IType
+	public sealed class ParameterizedType : Immutable, IType
 	{
 		sealed class Substitution : TypeVisitor
 		{
@@ -54,7 +54,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		readonly ITypeDefinition genericType;
 		readonly IType[] typeArguments;
 		
-		public ConstructedType(ITypeDefinition genericType, IEnumerable<IType> typeArguments)
+		public ParameterizedType(ITypeDefinition genericType, IEnumerable<IType> typeArguments)
 		{
 			if (genericType == null)
 				throw new ArgumentNullException("genericType");
@@ -63,7 +63,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			this.genericType = genericType;
 			this.typeArguments = typeArguments.ToArray(); // copy input array to ensure it isn't modified
 			if (this.typeArguments.Length == 0)
-				throw new ArgumentException("Cannot use ConstructedType with 0 type arguments.");
+				throw new ArgumentException("Cannot use ParameterizedType with 0 type arguments.");
 			if (genericType.TypeParameterCount != this.typeArguments.Length)
 				throw new ArgumentException("Number of type arguments must match the type definition's number of type parameters");
 			for (int i = 0; i < this.typeArguments.Length; i++) {
@@ -76,7 +76,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Fast internal version of the constructor. (no safety checks)
 		/// Keeps the array that was passed and assumes it won't be modified.
 		/// </summary>
-		internal ConstructedType(ITypeDefinition genericType, IType[] typeArguments)
+		internal ParameterizedType(ITypeDefinition genericType, IType[] typeArguments)
 		{
 			Debug.Assert(genericType.TypeParameterCount == typeArguments.Length);
 			this.genericType = genericType;
@@ -93,7 +93,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				if (declaringTypeDef != null && declaringTypeDef.TypeParameterCount > 0) {
 					IType[] newTypeArgs = new IType[declaringTypeDef.TypeParameterCount];
 					Array.Copy(this.typeArguments, 0, newTypeArgs, 0, newTypeArgs.Length);
-					return new ConstructedType(declaringTypeDef, newTypeArgs);
+					return new ParameterizedType(declaringTypeDef, newTypeArgs);
 				}
 				return declaringTypeDef;
 			}
@@ -238,7 +238,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		
 		public bool Equals(IType other)
 		{
-			ConstructedType c = other as ConstructedType;
+			ParameterizedType c = other as ParameterizedType;
 			if (c == null || typeArguments.Length != c.typeArguments.Length)
 				return false;
 			if (genericType.Equals(c.genericType)) {
@@ -264,7 +264,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		
 		public IType AcceptVisitor(TypeVisitor visitor)
 		{
-			return visitor.VisitConstructedType(this);
+			return visitor.VisitParameterizedType(this);
 		}
 		
 		public IType VisitChildren(TypeVisitor visitor)
@@ -282,15 +282,15 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			if (isSame)
 				return this;
 			else
-				return new ConstructedType(def, ta);
+				return new ParameterizedType(def, ta);
 		}
 	}
 	
 	/// <summary>
-	/// ConstructedTypeReference is a reference to generic class that specifies the type parameters.
+	/// ParameterizedTypeReference is a reference to generic class that specifies the type parameters.
 	/// Example: List&lt;string&gt;
 	/// </summary>
-	public sealed class ConstructedTypeReference : ITypeReference, ISupportsInterning
+	public sealed class ParameterizedTypeReference : ITypeReference, ISupportsInterning
 	{
 		public static ITypeReference Create(ITypeReference genericType, IEnumerable<ITypeReference> typeArguments)
 		{
@@ -305,16 +305,16 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				for (int i = 0; i < ta.Length; i++) {
 					ta[i] = (IType)typeArgs[i];
 				}
-				return new ConstructedType((ITypeDefinition)genericType, ta);
+				return new ParameterizedType((ITypeDefinition)genericType, ta);
 			} else {
-				return new ConstructedTypeReference(genericType, typeArgs);
+				return new ParameterizedTypeReference(genericType, typeArgs);
 			}
 		}
 		
 		ITypeReference genericType;
 		ITypeReference[] typeArguments;
 		
-		public ConstructedTypeReference(ITypeReference genericType, IEnumerable<ITypeReference> typeArguments)
+		public ParameterizedTypeReference(ITypeReference genericType, IEnumerable<ITypeReference> typeArguments)
 		{
 			if (genericType == null)
 				throw new ArgumentNullException("genericType");
@@ -353,7 +353,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				else
 					resolvedTypes[i] = SharedTypes.UnknownType;
 			}
-			return new ConstructedType(baseTypeDef, resolvedTypes);
+			return new ParameterizedType(baseTypeDef, resolvedTypes);
 		}
 		
 		public override string ToString()
@@ -393,7 +393,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		
 		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
 		{
-			ConstructedTypeReference o = other as ConstructedTypeReference;
+			ParameterizedTypeReference o = other as ParameterizedTypeReference;
 			if (o != null && genericType == o.genericType && typeArguments.Length == o.typeArguments.Length) {
 				for (int i = 0; i < typeArguments.Length; i++) {
 					if (typeArguments[i] != o.typeArguments[i])

ICSharpCode.NRefactory/TypeSystem/TypeVisitor.cs

@@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			return type.VisitChildren(this);
 		}
 		
-		public virtual IType VisitConstructedType(ConstructedType type)
+		public virtual IType VisitParameterizedType(ParameterizedType type)
 		{
 			return type.VisitChildren(this);
 		}