renamed Type

doc/CHANGES.txt

@@ -42,6 +42,7 @@ TODO inlining : substitute class+function type parameters in order to have fully
 	Dynamic type is now a class and not an enum
 	moved reflection support for core types from Boot to Type
 	fixed Type.getClassName/getEnumName/resolve for core flash9 types
+	renamed haxe.rtti.Type to haxe.rtti.CType (with changes in prefix)
 
 2008-04-05: 1.19
 	fixed flash9 Array.toString

std/haxe/ImportAll.hx

@@ -98,7 +98,7 @@ import haxe.remoting.SocketWrapper;
 #end
 
 import haxe.rtti.Infos;
-import haxe.rtti.Type;
+import haxe.rtti.CType;
 import haxe.rtti.XmlParser;
 import haxe.rtti.Generic;
 

std/haxe/rtti/Type.hx → std/haxe/rtti/CType.hx

@@ -4,19 +4,19 @@ typedef Path = String
 
 typedef Platforms = List<String>
 
-enum Type {
-	TUnknown;
-	TEnum( name : Path, params : List<Type> );
-	TClass( name : Path, params : List<Type> );
-	TTypedef( name : Path, params : List<Type> );
-	TFunction( args : List<{ name : String, opt : Bool, t : Type }>, ret : Type );
-	TAnonymous( fields : List<{ name : String, t : Type  }> );
-	TDynamic( ?t : Type );
+enum CType {
+	CUnknown;
+	CEnum( name : Path, params : List<CType> );
+	CClass( name : Path, params : List<CType> );
+	CTypedef( name : Path, params : List<CType> );
+	CFunction( args : List<{ name : String, opt : Bool, t : CType }>, ret : CType );
+	CAnonymous( fields : List<{ name : String, t : CType  }> );
+	CDynamic( ?t : CType );
 }
 
 typedef PathParams = {
 	var path : Path;
-	var params : List<Type>;
+	var params : List<CType>;
 }
 
 typedef TypeParams = Array<String> // no contraints
@@ -31,7 +31,7 @@ enum Rights {
 
 typedef ClassField = {
 	var name : String;
-	var type : Type;
+	var type : CType;
 	var isPublic : Bool;
 	var doc : String;
 	var get : Rights;
@@ -56,12 +56,12 @@ typedef Classdef = {> TypeInfos,
 	var interfaces : List<PathParams>;
 	var fields : List<ClassField>;
 	var statics : List<ClassField>;
-	var tdynamic : Null<Type>;
+	var tdynamic : Null<CType>;
 }
 
 typedef EnumField = {
 	var name : String;
-	var args : Null<List<{ name : String, opt : Bool, t : Type }>>;
+	var args : Null<List<{ name : String, opt : Bool, t : CType }>>;
 	var doc : String;
 	var platforms : Platforms;
 }
@@ -72,8 +72,8 @@ typedef Enumdef = {> TypeInfos,
 }
 
 typedef Typedef = {> TypeInfos,
-	var type : Type;
-	var types : Hash<Type>; // by platform
+	var type : CType;
+	var types : Hash<CType>; // by platform
 }
 
 enum TypeTree {
@@ -98,9 +98,9 @@ class TypeApi {
 		return inf;
 	}
 
-	public static function isVar( t : Type ) {
+	public static function isVar( t : CType ) {
 		return switch( t ) {
-		case TFunction(_,_): false;
+		case CFunction(_,_): false;
 		default: true;
 		}
 	}
@@ -134,46 +134,46 @@ class TypeApi {
 		return false;
 	}
 
-	public static function typeEq( t1 : Type, t2 : Type ) {
+	public static function typeEq( t1 : CType, t2 : CType ) {
 		switch( t1 ) {
-		case TUnknown: return t2 == TUnknown;
-		case TEnum(name,params):
+		case CUnknown: return t2 == CUnknown;
+		case CEnum(name,params):
 			switch( t2 ) {
-			case TEnum(name2,params2):
+			case CEnum(name2,params2):
 				return name == name2 && leq(typeEq,params,params2);
 			default:
 			}
-		case TClass(name,params):
+		case CClass(name,params):
 			switch( t2 ) {
-			case TClass(name2,params2):
+			case CClass(name2,params2):
 				return name == name2 && leq(typeEq,params,params2);
 			default:
 			}
-		case TTypedef(name,params):
+		case CTypedef(name,params):
 			switch( t2 ) {
-			case TTypedef(name2,params2):
+			case CTypedef(name2,params2):
 				return name == name2 && leq(typeEq,params,params2);
 			default:
 			}
-		case TFunction(args,ret):
+		case CFunction(args,ret):
 			switch( t2 ) {
-			case TFunction(args2,ret2):
+			case CFunction(args2,ret2):
 				return leq(function(a,b) {
 					return a.name == b.name && a.opt == b.opt && typeEq(a.t,b.t);
 				},args,args2) && typeEq(ret,ret2);
 			default:
 			}
-		case TAnonymous(fields):
+		case CAnonymous(fields):
 			switch( t2 ) {
-			case TAnonymous(fields2):
+			case CAnonymous(fields2):
 				return leq(function(a,b) {
 					return a.name == b.name && typeEq(a.t,b.t);
 				},fields,fields2);
 			default:
 			}
-		case TDynamic(t):
+		case CDynamic(t):
 			switch( t2 ) {
-			case TDynamic(t2):
+			case CDynamic(t2):
 				if( (t == null) != (t2 == null) )
 					return false;
 				return t == null || typeEq(t,t2);

std/haxe/rtti/XmlParser.hx

@@ -1,5 +1,5 @@
 package haxe.rtti;
-import haxe.rtti.Type;
+import haxe.rtti.CType;
 import haxe.xml.Fast;
 
 class XmlParser {
@@ -369,16 +369,16 @@ class XmlParser {
 		};
 	}
 
-	function xtype( x : Fast ) : Type {
+	function xtype( x : Fast ) : CType {
 		return switch( x.name ) {
 		case "unknown":
-			TUnknown;
+			CUnknown;
 		case "e":
-			TEnum(mkPath(x.att.path),xtypeparams(x));
+			CEnum(mkPath(x.att.path),xtypeparams(x));
 		case "c":
-			TClass(mkPath(x.att.path),xtypeparams(x));
+			CClass(mkPath(x.att.path),xtypeparams(x));
 		case "t":
-			TTypedef(mkPath(x.att.path),xtypeparams(x));
+			CTypedef(mkPath(x.att.path),xtypeparams(x));
 		case "f":
 			var args = new List();
 			var aname = x.att.a.split(":");
@@ -400,7 +400,7 @@ class XmlParser {
 			}
 			var ret = args.last();
 			args.remove(ret);
-			TFunction(args,ret.t);
+			CFunction(args,ret.t);
 		case "a":
 			var fields = new List();
 			for( f in x.elements )
@@ -408,19 +408,19 @@ class XmlParser {
 					name : f.name,
 					t : xtype(new Fast(f.x.firstElement())),
 				});
-			TAnonymous(fields);
+			CAnonymous(fields);
 		case "d":
 			var t = null;
 			var tx = x.x.firstElement();
 			if( tx != null )
 				t = xtype(new Fast(tx));
-			TDynamic(t);
+			CDynamic(t);
 		default:
 			xerror(x);
 		}
 	}
 
-	function xtypeparams( x : Fast ) : List<Type> {
+	function xtypeparams( x : Fast ) : List<CType> {
 		var p = new List();
 		for( c in x.elements )
 			p.add(xtype(c));

std/tools/haxedoc/HtmlPrinter.hx

@@ -1,5 +1,5 @@
 package tools.haxedoc;
-import haxe.rtti.Type;
+import haxe.rtti.CType;
 
 class HtmlPrinter {
 
@@ -244,7 +244,7 @@ class HtmlPrinter {
 		if( stat ) keyword("static");
 		var isMethod = false;
 		switch( f.type ) {
-		case TFunction(args,ret):
+		case CFunction(args,ret):
 			if( f.get == RNormal && (f.set == RNormal || f.set == RF9Dynamic) ) {
 				isMethod = true;
 				if( f.set == RF9Dynamic )
@@ -365,7 +365,7 @@ class HtmlPrinter {
 
 	function processTypedefType(t,all,platforms) {
 		switch( t ) {
-		case TAnonymous(fields):
+		case CAnonymous(fields):
 			print('<dl>');
 			for( f in fields ) {
 				processClassField(all,{
@@ -392,7 +392,7 @@ class HtmlPrinter {
 		}
 	}
 
-	function processPath( path : Path, ?params : List<Type> ) {
+	function processPath( path : Path, ?params : List<CType> ) {
 		print(makePathUrl(path,"type"));
 		if( params != null && !params.isEmpty() ) {
 			print("&lt;");
@@ -402,17 +402,17 @@ class HtmlPrinter {
 		}
 	}
 
-	function processType( t : Type ) {
+	function processType( t : CType ) {
 		switch( t ) {
-		case TUnknown:
+		case CUnknown:
 			print("Unknown");
-		case TEnum(path,params):
+		case CEnum(path,params):
 			processPath(path,params);
-		case TClass(path,params):
+		case CClass(path,params):
 			processPath(path,params);
-		case TTypedef(path,params):
+		case CTypedef(path,params):
 			processPath(path,params);
-		case TFunction(args,ret):
+		case CFunction(args,ret):
 			if( args.isEmpty() ) {
 				processPath("Void");
 				print(" -> ");
@@ -426,7 +426,7 @@ class HtmlPrinter {
 				print(" -> ");
 			}
 			processTypeFun(ret,false);
-		case TAnonymous(fields):
+		case CAnonymous(fields):
 			print("{ ");
 			var me = this;
 			display(fields,function(f) {
@@ -434,7 +434,7 @@ class HtmlPrinter {
 				me.processType(f.t);
 			},", ");
 			print("}");
-		case TDynamic(t):
+		case CDynamic(t):
 			if( t == null )
 				processPath("Dynamic");
 			else {
@@ -445,8 +445,8 @@ class HtmlPrinter {
 		}
 	}
 
-	function processTypeFun( t : Type, isArg ) {
-		var parent =  switch( t ) { case TFunction(_,_): true; case TEnum(n,_): isArg && n == "Void"; default : false; };
+	function processTypeFun( t : CType, isArg ) {
+		var parent =  switch( t ) { case CFunction(_,_): true; case CEnum(n,_): isArg && n == "Void"; default : false; };
 		if( parent )
 			print("(");
 		processType(t);

std/tools/haxedoc/Main.hx

@@ -23,7 +23,7 @@
  * DAMAGE.
  */
 package tools.haxedoc;
-import haxe.rtti.Type;
+import haxe.rtti.CType;
 
 class Main {