Add AstType.ToTypeReference() method.

ICSharpCode.NRefactory.CSharp/Ast/AstType.cs

@@ -18,6 +18,7 @@
 
 using System;
 using System.Collections.Generic;
+using ICSharpCode.NRefactory.CSharp.Resolver;
 using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.CSharp
@@ -47,6 +48,11 @@ namespace ICSharpCode.NRefactory.CSharp
 			{
 				return other == null || other.IsNull;
 			}
+			
+			public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode)
+			{
+				return SpecialType.UnknownType;
+			}
 		}
 		#endregion
 		
@@ -74,6 +80,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				return visitor.VisitPatternPlaceholder(this, child, data);
 			}
 			
+			public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode)
+			{
+				throw new NotSupportedException();
+			}
+			
 			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
 			{
 				return child.DoMatch(other, match);
@@ -95,6 +106,11 @@ namespace ICSharpCode.NRefactory.CSharp
 			return (AstType)base.Clone();
 		}
 		
+		/// <summary>
+		/// Create an ITypeReference for this AstType.
+		/// </summary>
+		public abstract ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type);
+		
 		/// <summary>
 		/// Creates a pointer type from this type by nesting it in a <see cref="ComposedType"/>.
 		/// If this type already is a pointer type, this method just increases the PointerRank of the existing pointer type.
@@ -153,42 +169,5 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			return new TypeReferenceExpression { Type = this }.Invoke(methodName, typeArguments, arguments);
 		}
-		
-		public static AstType Create(Type type)
-		{
-			switch (Type.GetTypeCode(type)) {
-				case TypeCode.Object:
-					return new PrimitiveType("object");
-				case TypeCode.Boolean:
-					return new PrimitiveType("bool");
-				case TypeCode.Char:
-					return new PrimitiveType("char");
-				case TypeCode.SByte:
-					return new PrimitiveType("sbyte");
-				case TypeCode.Byte:
-					return new PrimitiveType("byte");
-				case TypeCode.Int16:
-					return new PrimitiveType("short");
-				case TypeCode.UInt16:
-					return new PrimitiveType("ushort");
-				case TypeCode.Int32:
-					return new PrimitiveType("int");
-				case TypeCode.UInt32:
-					return new PrimitiveType("uint");
-				case TypeCode.Int64:
-					return new PrimitiveType("long");
-				case TypeCode.UInt64:
-					return new PrimitiveType("ulong");
-				case TypeCode.Single:
-					return new PrimitiveType("float");
-				case TypeCode.Double:
-					return new PrimitiveType("double");
-				case TypeCode.Decimal:
-					return new PrimitiveType("decimal");
-				case TypeCode.String:
-					return new PrimitiveType("string");
-			}
-			return new SimpleType(type.FullName); // TODO: implement this correctly
-		}
 	}
 }

ICSharpCode.NRefactory.CSharp/Ast/ComposedType.cs

@@ -27,6 +27,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
@@ -114,6 +115,22 @@ namespace ICSharpCode.NRefactory.CSharp
 			InsertChildBefore(this.ArraySpecifiers.FirstOrDefault(), new ArraySpecifier(dimensions), ArraySpecifierRole);
 			return this;
 		}
+		
+		public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
+		{
+			ITypeReference t = this.BaseType.ToTypeReference(lookupMode);
+			if (this.HasNullableSpecifier) {
+				t = NullableType.Create(t);
+			}
+			int pointerRank = this.PointerRank;
+			for (int i = 0; i < pointerRank; i++) {
+				t = new PointerTypeReference(t);
+			}
+			foreach (var a in this.ArraySpecifiers.Reverse()) {
+				t = new ArrayTypeReference(t, a.Dimensions);
+			}
+			return t;
+		}
 	}
 	
 	/// <summary>

ICSharpCode.NRefactory.CSharp/Ast/Expressions/Expression.cs

@@ -202,30 +202,15 @@ namespace ICSharpCode.NRefactory.CSharp
 			return new CastExpression { Type = type,  Expression = this };
 		}
 		
-		public CastExpression CastTo(Type type)
-		{
-			return new CastExpression { Type = AstType.Create(type),  Expression = this };
-		}
-		
 		public AsExpression CastAs(AstType type)
 		{
 			return new AsExpression { Type = type,  Expression = this };
 		}
 		
-		public AsExpression CastAs(Type type)
-		{
-			return new AsExpression { Type = AstType.Create(type),  Expression = this };
-		}
-		
 		public IsExpression IsType(AstType type)
 		{
 			return new IsExpression { Type = type,  Expression = this };
 		}
-		
-		public IsExpression IsType(Type type)
-		{
-			return new IsExpression { Type = AstType.Create(type),  Expression = this };
-		}
 		#endregion
 	}
 }

ICSharpCode.NRefactory.CSharp/Ast/MemberType.cs

@@ -28,6 +28,8 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using ICSharpCode.NRefactory.CSharp.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
@@ -114,6 +116,28 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 			return b.ToString();
 		}
+		
+		public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
+		{
+			TypeOrNamespaceReference t;
+			if (this.IsDoubleColon) {
+				SimpleType st = this.Target as SimpleType;
+				if (st != null) {
+					t = new AliasNamespaceReference(st.Identifier);
+				} else {
+					t = null;
+				}
+			} else {
+				t = this.Target.ToTypeReference(lookupMode) as TypeOrNamespaceReference;
+			}
+			if (t == null)
+				return SpecialType.UnknownType;
+			var typeArguments = new List<ITypeReference>();
+			foreach (var ta in this.TypeArguments) {
+				typeArguments.Add(ta.ToTypeReference(lookupMode));
+			}
+			return new MemberTypeOrNamespaceReference(t, this.MemberName, typeArguments);
+		}
 	}
 }
 

ICSharpCode.NRefactory.CSharp/Ast/PrimitiveType.cs

@@ -26,6 +26,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using ICSharpCode.NRefactory.CSharp.Resolver;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
@@ -34,6 +37,10 @@ namespace ICSharpCode.NRefactory.CSharp
 		public string Keyword { get; set; }
 		public TextLocation Location { get; set; }
 		
+		public KnownTypeCode KnownTypeCode {
+			get { return GetTypeCodeForPrimitiveType(this.Keyword); }
+		}
+		
 		public PrimitiveType()
 		{
 		}
@@ -83,6 +90,55 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			return Keyword ?? base.ToString();
 		}
+		
+		public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode)
+		{
+			KnownTypeCode typeCode = GetTypeCodeForPrimitiveType(this.Keyword);
+			if (typeCode == KnownTypeCode.None)
+				return new UnknownType(null, this.Keyword);
+			else
+				return KnownTypeReference.Get(typeCode);
+		}
+		
+		public static KnownTypeCode GetTypeCodeForPrimitiveType(string keyword)
+		{
+			switch (keyword) {
+				case "string":
+					return KnownTypeCode.String;
+				case "int":
+					return KnownTypeCode.Int32;
+				case "uint":
+					return KnownTypeCode.UInt32;
+				case "object":
+					return KnownTypeCode.Object;
+				case "bool":
+					return KnownTypeCode.Boolean;
+				case "sbyte":
+					return KnownTypeCode.SByte;
+				case "byte":
+					return KnownTypeCode.Byte;
+				case "short":
+					return KnownTypeCode.Int16;
+				case "ushort":
+					return KnownTypeCode.UInt16;
+				case "long":
+					return KnownTypeCode.Int64;
+				case "ulong":
+					return KnownTypeCode.UInt64;
+				case "float":
+					return KnownTypeCode.Single;
+				case "double":
+					return KnownTypeCode.Double;
+				case "decimal":
+					return KnownTypeCode.Decimal;
+				case "char":
+					return KnownTypeCode.Char;
+				case "void":
+					return KnownTypeCode.Void;
+				default:
+					return KnownTypeCode.None;
+			}
+		}
 	}
 }
 

ICSharpCode.NRefactory.CSharp/Ast/SimpleType.cs

@@ -28,6 +28,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using ICSharpCode.NRefactory.CSharp.Resolver;
+using ICSharpCode.NRefactory.CSharp.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.NRefactory.CSharp
 {
@@ -53,6 +56,11 @@ namespace ICSharpCode.NRefactory.CSharp
 			{
 				return other == null || other.IsNull;
 			}
+			
+			public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode)
+			{
+				return SpecialType.UnknownType;
+			}
 		}
 		#endregion
 		
@@ -130,6 +138,19 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 			return b.ToString();
 		}
+		
+		public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
+		{
+			var typeArguments = new List<ITypeReference>();
+			foreach (var ta in this.TypeArguments) {
+				typeArguments.Add(ta.ToTypeReference(lookupMode));
+			}
+			if (typeArguments.Count == 0 && string.IsNullOrEmpty(this.Identifier)) {
+				// empty SimpleType is used for typeof(List<>).
+				return SpecialType.UnboundTypeArgument;
+			}
+			return new SimpleTypeOrNamespaceReference(this.Identifier, typeArguments, lookupMode);
+		}
 	}
 }
 

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
   <PropertyGroup>
     <ProjectGuid>{53DCA265-3C3C-42F9-B647-F72BA678122B}</ProjectGuid>
@@ -291,10 +291,10 @@
     <Compile Include="Resolver\OverloadResolutionErrors.cs" />
     <Compile Include="Resolver\ResolveAtLocation.cs" />
     <Compile Include="Resolver\ResolveVisitor.cs" />
-    <Compile Include="Resolver\SimpleNameLookupMode.cs" />
     <Compile Include="Resolver\TypeInference.cs" />
     <Compile Include="Completion\ICompletionDataFactory.cs" />
     <Compile Include="Completion\IParameterCompletionDataFactory.cs" />
+    <Compile Include="SimpleNameLookupMode.cs" />
     <Compile Include="TypeSystem\AliasNamespaceReference.cs" />
     <Compile Include="TypeSystem\AttributeTypeReference.cs" />
     <Compile Include="TypeSystem\ConstantValues.cs" />

ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs

@@ -1232,13 +1232,12 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		CodeObject IAstVisitor<object, CodeObject>.VisitPrimitiveType(PrimitiveType primitiveType, object data)
 		{
-			string keyword = primitiveType.Keyword;
-			KnownTypeCode typeCode = TypeSystemConvertVisitor.GetTypeCodeForPrimitiveType(keyword);
+			KnownTypeCode typeCode = primitiveType.KnownTypeCode;
 			if (typeCode != KnownTypeCode.None) {
 				KnownTypeReference ktr = KnownTypeReference.Get(typeCode);
 				return new CodeTypeReference(ktr.Namespace + "." + ktr.Name);
 			}
-			return new CodeTypeReference(keyword);
+			return new CodeTypeReference(primitiveType.Keyword);
 		}
 		
 		CodeObject IAstVisitor<object, CodeObject>.VisitComment (Comment comment, object data)

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -2875,7 +2875,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			if (!resolverEnabled)
 				return null;
-			KnownTypeCode typeCode = TypeSystemConvertVisitor.GetTypeCodeForPrimitiveType(primitiveType.Keyword);
+			KnownTypeCode typeCode = primitiveType.KnownTypeCode;
 			if (typeCode == KnownTypeCode.None && primitiveType.Parent is Constraint && primitiveType.Role == Constraint.BaseTypeRole) {
 				switch (primitiveType.Keyword) {
 					case "class":

ICSharpCode.NRefactory.CSharp/SimpleNameLookupMode.cs

@@ -18,7 +18,7 @@
 
 using System;
 
-namespace ICSharpCode.NRefactory.CSharp.Resolver
+namespace ICSharpCode.NRefactory.CSharp
 {
 	public enum SimpleNameLookupMode
 	{

ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs

@@ -867,110 +867,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		#region Types
 		public static ITypeReference ConvertType(AstType type, SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
 		{
-			SimpleType s = type as SimpleType;
-			if (s != null) {
-				List<ITypeReference> typeArguments = new List<ITypeReference>();
-				foreach (var ta in s.TypeArguments) {
-					typeArguments.Add(ConvertType(ta, lookupMode));
-				}
-				if (typeArguments.Count == 0 && string.IsNullOrEmpty(s.Identifier)) {
-					// empty SimpleType is used for typeof(List<>).
-					return SpecialType.UnboundTypeArgument;
-				}
-				return new SimpleTypeOrNamespaceReference(s.Identifier, typeArguments, lookupMode);
-			}
-			
-			PrimitiveType p = type as PrimitiveType;
-			if (p != null) {
-				return ConvertPrimitiveType(p.Keyword);
-			}
-			MemberType m = type as MemberType;
-			if (m != null) {
-				TypeOrNamespaceReference t;
-				if (m.IsDoubleColon) {
-					SimpleType st = m.Target as SimpleType;
-					if (st != null) {
-						t = new AliasNamespaceReference(st.Identifier);
-					} else {
-						t = null;
-					}
-				} else {
-					t = ConvertType(m.Target, lookupMode) as TypeOrNamespaceReference;
-				}
-				if (t == null)
-					return SpecialType.UnknownType;
-				List<ITypeReference> typeArguments = new List<ITypeReference>();
-				foreach (var ta in m.TypeArguments) {
-					typeArguments.Add(ConvertType(ta, lookupMode));
-				}
-				return new MemberTypeOrNamespaceReference(t, m.MemberName, typeArguments);
-			}
-			ComposedType c = type as ComposedType;
-			if (c != null) {
-				ITypeReference t = ConvertType(c.BaseType, lookupMode);
-				if (c.HasNullableSpecifier) {
-					t = NullableType.Create(t);
-				}
-				for (int i = 0; i < c.PointerRank; i++) {
-					t = new PointerTypeReference(t);
-				}
-				foreach (var a in c.ArraySpecifiers.Reverse()) {
-					t = new ArrayTypeReference(t, a.Dimensions);
-				}
-				return t;
-			}
-			if (!type.IsNull)
-				Debug.WriteLine("Unknown node used as type: " + type);
-			return SpecialType.UnknownType;
-		}
-		
-		public static ITypeReference ConvertPrimitiveType(string keyword)
-		{
-			KnownTypeCode typeCode = GetTypeCodeForPrimitiveType(keyword);
-			if (typeCode == KnownTypeCode.None)
-				return new UnknownType(null, keyword);
-			else
-				return KnownTypeReference.Get(typeCode);
-		}
-		
-		public static KnownTypeCode GetTypeCodeForPrimitiveType(string keyword)
-		{
-			switch (keyword) {
-				case "string":
-					return KnownTypeCode.String;
-				case "int":
-					return KnownTypeCode.Int32;
-				case "uint":
-					return KnownTypeCode.UInt32;
-				case "object":
-					return KnownTypeCode.Object;
-				case "bool":
-					return KnownTypeCode.Boolean;
-				case "sbyte":
-					return KnownTypeCode.SByte;
-				case "byte":
-					return KnownTypeCode.Byte;
-				case "short":
-					return KnownTypeCode.Int16;
-				case "ushort":
-					return KnownTypeCode.UInt16;
-				case "long":
-					return KnownTypeCode.Int64;
-				case "ulong":
-					return KnownTypeCode.UInt64;
-				case "float":
-					return KnownTypeCode.Single;
-				case "double":
-					return KnownTypeCode.Double;
-				case "decimal":
-					return KnownTypeCode.Decimal;
-				case "char":
-					return KnownTypeCode.Char;
-				case "void":
-					return KnownTypeCode.Void;
-				default:
-					return KnownTypeCode.None;
-			}
+			return type.ToTypeReference(lookupMode);
 		}
 		#endregion