Context Navigation

← Previous Changeset
Next Changeset →

Changeset 3187

Timestamp:

12/10/08 13:18:29 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Removed optional fields of _RewriteFnRef, CoercionInvocation?, MethodInvocation?, ArrayElement?, and ArrayElements?.

Location:

trunk/ProjectFortress

Files:

: 9 modified

astgen/Fortress.ast (modified) (5 diffs)
src/com/sun/fortress/compiler/desugarer/DottedMethodRewriteVisitor.java (modified) (2 diffs)
src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (4 diffs)
src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (4 diffs)
src/com/sun/fortress/interpreter/rewrite/RewriteInPresenceOfTypeInfoVisitor.java (modified) (1 diff)
src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (4 diffs)
src/com/sun/fortress/parser/Expression.rats (modified) (3 diffs)
src/com/sun/fortress/parser/Literal.rats (modified) (1 diff)
src/com/sun/fortress/parser_util/FortressUtil.java (modified) (6 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/ProjectFortress/astgen/Fortress.ast

r3186	r3187
874	874	* list from a FnRef into something else.
875	875	*/
876		_RewriteFnRef(Expr fnExpr,
877		List<StaticArg> staticArgs
878		= Collections.<StaticArg>emptyList());
	876	_RewriteFnRef(Expr fnExpr, List<StaticArg> staticArgs);
879	877	/**
880	878	* Temporarily, until closure conversion is always on-line,
…	…
963	961	*/
964	962	CoercionInvocation(BaseType toType,
965		List<StaticArg> staticArgs
966		= Collections.<StaticArg>emptyList(),
967		Expr arg);
	963	List<StaticArg> staticArgs, Expr arg);
968	964	/**
969	965	* a method invocation
…	…
975	971	*/
976	972	MethodInvocation(Expr obj, Id method,
977		List<StaticArg> staticArgs
978		= Collections.<StaticArg>emptyList(),
979		Expr arg);
	973	List<StaticArg> staticArgs, Expr arg);
980	974	/**
981	975	* primary expression without any dots
…	…
995	989	* e.g.) [1 2 3; 4 5 6; 7 8 9]
996	990	*/
997		abstract ArrayExpr(List<StaticArg> staticArgs
998		= Collections.<StaticArg>emptyList());
	991	abstract ArrayExpr(List<StaticArg> staticArgs);
999	992	/**
1000	993	* array with a single element
…	…
1006	999	* e.g.) [3 4 5; 6 7 8]
1007	1000	*/
1008		ArrayElements(int dimension,
1009		List<ArrayExpr> elements,
1010		boolean outermost = false);
	1001	ArrayElements(int dimension, List<ArrayExpr> elements,
	1002	boolean outermost);
1011	1003	/**
1012	1004	* type

trunk/ProjectFortress/src/com/sun/fortress/compiler/desugarer/DottedMethodRewriteVisitor.java

r3182	r3187
82	82	if ( ! (name instanceof Id) )
83	83	bug(name, "The name field of FnRef should be Id.");
84		MethodInvocation mi = new MethodInvocation( fnRef.getSpan(),
85		fnRef.isParenthesized(), fnRef.getExprType(), receiver,
86		(Id)name, fnRef.getStaticArgs(), arg );
	84	MethodInvocation mi = ExprFactory.makeMethodInvocation( fnRef.getSpan(),
	85	fnRef.isParenthesized(),
	86	fnRef.getExprType(),
	87	receiver, (Id)name,
	88	fnRef.getStaticArgs(),
	89	arg );
87	90	return mi;
88	91	}
…	…
105	108	bug(name, "The name field of FnRef should be Id.");
106	109
107		mi = new MethodInvocation( fnRef.getSpan(),
108		fnRef.isParenthesized(), fnRef.getExprType(), receiver,
109		(Id)name, fnRef.getStaticArgs(), argExpr );
	110	mi = ExprFactory.makeMethodInvocation( fnRef.getSpan(),
	111	fnRef.isParenthesized(),
	112	fnRef.getExprType(),
	113	receiver, (Id)name,
	114	fnRef.getStaticArgs(),
	115	argExpr );
110	116
111	117	return mi;

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeChecker.java

r3184	r3187
1066	1066	IntArg size = NodeFactory.makeIntArgVal(""+1);
1067	1067	Type t=Types.makeArrayKType(1, Useful.list(elem, lower, size));
1068		Node new_node=new ArrayElement(that.getSpan(), that.isParenthesized(), Option.some(t), (List<StaticArg>) TypeCheckerResult.astFromResults(staticArgs_result), (Expr) element_result.ast());
	1068	Node new_node=ExprFactory.makeArrayElement(that.getSpan(), that.isParenthesized(),
	1069	Option.some(t),
	1070	(List<StaticArg>) TypeCheckerResult.astFromResults(staticArgs_result),
	1071	(Expr) element_result.ast());
1069	1072	return TypeCheckerResult.compose(new_node,t,this.subtypeChecker, element_result);
1070	1073	}
…	…
1076	1079	element_result.type().unwrap()+" must be a subtype of "+((TypeArg)that.getStaticArgs().get(0)).getTypeArg());
1077	1080	Type t=Types.makeArrayKType(1, that.getStaticArgs());
1078		Node new_node=new ArrayElement(that.getSpan(), that.isParenthesized(), Option.some(t), (List<StaticArg>) TypeCheckerResult.astFromResults(staticArgs_result), (Expr) element_result.ast());
	1081	Node new_node=ExprFactory.makeArrayElement(that.getSpan(), that.isParenthesized(),
	1082	Option.some(t),
	1083	(List<StaticArg>) TypeCheckerResult.astFromResults(staticArgs_result),
	1084	(Expr) element_result.ast());
1079	1085	return TypeCheckerResult.compose(new_node,t,this.subtypeChecker, element_result, res,
1080	1086	TypeCheckerResult.compose(new_node,this.subtypeChecker,staticArgs_result),
…	…
1242	1248	}
1243	1249	};
1244		ArrayElements new_node=new ArrayElements(that.getSpan(), that.isParenthesized(), Option.some(return_type) , that.getStaticArgs(),
1245		that.getDimension(), Useful.list(IterUtil.map(subarrays, get_expr)), that.isOutermost());
	1250	ArrayElements new_node=ExprFactory.makeArrayElements(that.getSpan(),
	1251	that.isParenthesized(),
	1252	Option.some(return_type) ,
	1253	that.getStaticArgs(),
	1254	that.getDimension(),
	1255	Useful.list(IterUtil.map(subarrays, get_expr)),
	1256	that.isOutermost());
1246	1257
1247	1258	all_results.add(new TypeCheckerResult(new_node, accumulated_constraints));
…	…
3343	3354	Type range = subtypeChecker.meet(ranges);
3344	3355	range = subtypeChecker.normalize(range);
3345		MethodInvocation new_node = ~~new~~ MethodInvocation(that.getSpan(),
3346		that.isParenthesized(),
3347		Option.<Type>some(range),
3348		(Expr)obj_result.ast(),
3349		that.getMethod(),
	3356	MethodInvocation new_node = ExprFactory.makeMethodInvocation(that.getSpan(),
	3357	that.isParenthesized(),
	3358	Option.<Type>some(range),
	3359	(Expr)obj_result.ast(),
	3360	that.getMethod(),
3350	3361	(List<StaticArg>)TypeCheckerResult.astFromResults(staticArgs_result),
3351	3362	(Expr)arg_result.ast());

trunk/ProjectFortress/src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java

r3185	r3187
1116	1116	Environment.TOP_LEVEL)));
1117	1117
1118		_RewriteFnRef fn = new _RewriteFnRef(s.getSpan(), in_fn, args);
	1118	_RewriteFnRef fn = new _RewriteFnRef(s.getSpan(), false, Option.<Type>none(),
	1119	in_fn, args);
1119	1120
1120	1121	List<Param> params = Collections.emptyList();
…	…
1599	1600	VarRef vre = (VarRef) expr;
1600	1601	if (vre.getLexicalDepth() == -1) {
1601		return ~~new~~ MethodInvocation(node.getSpan(),
1602		false,
	1602	return ExprFactory.makeMethodInvocation(node.getSpan(),
	1603	false, node.getExprType(),
1603	1604	ExprFactory.makeVarRef(node.getSpan(), WellKnownNames.secretSelfName), // this will rewrite in the future.
1604	1605	(Id) vre.getVarId(),
…	…
1612	1613	FieldRef selfDotSomething = (FieldRef) visit(first);
1613	1614
1614		return ~~new~~ MethodInvocation(node.getSpan(),
1615		false,
	1615	return ExprFactory.makeMethodInvocation(node.getSpan(),
	1616	false, node.getExprType(),
1616	1617	selfDotSomething.getObj(), // this will rewrite in the future.
1617	1618	selfDotSomething.getField(),
…	…
1637	1638	Node arg = visit(((ExprMI)node.getRest().get(0)).getExpr());
1638	1639
1639		return ~~new~~ MethodInvocation(node.getSpan(),
1640		false,
	1640	return ExprFactory.makeMethodInvocation(node.getSpan(),
	1641	false, node.getExprType(),
1641	1642	selfDotSomething.getObj(), // this will rewrite in the future.
1642	1643	selfDotSomething.getField(),

trunk/ProjectFortress/src/com/sun/fortress/interpreter/rewrite/RewriteInPresenceOfTypeInfoVisitor.java

r3156	r3187
54	54	if (sargs.size() > 0)
55	55	return (new _RewriteFnRef(fr.getSpan(),
56		fr.isParenthesized(),
	56	fr.isParenthesized(),
	57	fr.getExprType(),
57	58	new VarRef(id.getSpan(),
58	59	id,
59	60	Collections.<StaticArg>emptyList()),
60		sargs)).accept(this);
	61	sargs)).accept(this);
61	62
62	63	else {

trunk/ProjectFortress/src/com/sun/fortress/nodes_util/ExprFactory.java

r3186	r3187
38	38
39	39	public class ExprFactory {
	40
	41	public static ArrayElement makeArrayElement(Expr elem) {
	42	return makeArrayElement(elem.getSpan(), false, Option.<Type>none(),
	43	Collections.<StaticArg>emptyList(), elem);
	44	}
	45
	46	public static ArrayElement makeArrayElement(Span span, boolean parenthesized,
	47	Option<Type> ty,
	48	List<StaticArg> staticArgs,
	49	Expr elem) {
	50	return new ArrayElement(span, parenthesized, ty, staticArgs, elem);
	51	}
	52
	53	public static ArrayElements makeArrayElements(Span span, int dim,
	54	List<ArrayExpr> elems) {
	55	return makeArrayElements(span, false, Option.<Type>none(),
	56	Collections.<StaticArg>emptyList(), dim, elems,
	57	false);
	58	}
	59
	60	public static ArrayElements makeArrayElements(ArrayElements a,
	61	boolean outermost) {
	62	return makeArrayElements(a.getSpan(), a.isParenthesized(), a.getExprType(),
	63	a.getStaticArgs(), a.getDimension(),
	64	a.getElements(), outermost);
	65	}
	66
	67	public static ArrayElements makeArrayElements(ArrayElements a,
	68	List<StaticArg> staticArgs,
	69	boolean outermost) {
	70	return makeArrayElements(a.getSpan(), a.isParenthesized(), a.getExprType(),
	71	staticArgs, a.getDimension(), a.getElements(),
	72	outermost);
	73	}
	74
	75	public static ArrayElements makeArrayElements(Span span, boolean parenthesized,
	76	Option<Type> ty,
	77	List<StaticArg> staticArgs,
	78	int dim,
	79	List<ArrayExpr> elems,
	80	boolean outermost) {
	81	return new ArrayElements(span, parenthesized, ty, staticArgs, dim, elems,
	82	outermost);
	83	}
	84
	85	public static MethodInvocation makeMethodInvocation(FieldRef that, Expr obj,
	86	Id field, Expr expr) {
	87	return makeMethodInvocation(that.getSpan(), that.isParenthesized(),
	88	that.getExprType(), obj, field, expr);
	89	}
	90
	91	public static MethodInvocation makeMethodInvocation(Span span,
	92	Expr receiver,
	93	Id method,
	94	Expr arg) {
	95	return makeMethodInvocation(span, false, Option.<Type>none(),
	96	receiver, method, arg);
	97	}
	98	public static MethodInvocation makeMethodInvocation(Span span,
	99	Expr receiver,
	100	Id method,
	101	List<StaticArg> staticArgs,
	102	Expr arg) {
	103	return makeMethodInvocation(span, false, Option.<Type>none(),
	104	receiver, method, staticArgs, arg);
	105	}
	106
	107	public static MethodInvocation makeMethodInvocation(Span span,
	108	boolean isParenthesized,
	109	Option<Type> type,
	110	Expr obj, Id field,
	111	Expr expr) {
	112	return makeMethodInvocation(span, isParenthesized, type, obj, field,
	113	Collections.<StaticArg>emptyList(), expr);
	114	}
	115
	116	public static MethodInvocation makeMethodInvocation(Span span,
	117	boolean isParenthesized,
	118	Option<Type> type,
	119	Expr obj, Id field,
	120	List<StaticArg> staticArgs,
	121	Expr expr) {
	122	return new MethodInvocation(span, isParenthesized, type, obj, field,
	123	staticArgs, expr);
	124	}
40	125
41	126	public static CharLiteralExpr makeCharLiteralExpr(Span span, String s) {
…	…
466	551	}
467	552
468		~~public static MethodInvocation makeMethodInvocation(Span span,~~
469		~~boolean isParenthesized,~~
470		~~Option<Type> type,~~
471		~~Expr obj,~~
472		~~Id field, Expr expr) {~~
473		~~return new MethodInvocation(span, isParenthesized, type, obj,~~
474		~~field, expr);~~
475		}
476
477		~~public static MethodInvocation makeMethodInvocation(FieldRef that, Expr obj,~~
478		~~Id field, Expr expr) {~~
479		~~return new MethodInvocation(that.getSpan(), that.isParenthesized(), obj,~~
480		~~field, expr);~~
481		}
482
483	553	public static VarRef makeVarRef(VarRef old, int depth) {
484	554	return new VarRef(old.getSpan(), old.isParenthesized(), old.getVarId(),
…	…
868	938	that.getArgs());
869	939	}
870		public Expr forArrayElement(ArrayElement e) {
871		return new ArrayElement(e.getSpan(), true, e.getElement());
	940	public Expr forArrayElement(ArrayElement e) {
	941	return makeArrayElement(e.getSpan(), true, e.getExprType(),
	942	e.getStaticArgs(), e.getElement());
872	943	}
873	944	public Expr forArrayElements(ArrayElements e) {
874		return new ArrayElements(e.getSpan(), true, e.getDimension(),
875		e.getElements());
	945	return makeArrayElements(e.getSpan(), true, e.getExprType(),
	946	e.getStaticArgs(), e.getDimension(),
	947	e.getElements(), e.isOutermost());
876	948	}
877	949	public Expr forFloatLiteralExpr(FloatLiteralExpr e) {
…	…
910	982	}
911	983	public Expr forMethodInvocation(MethodInvocation e) {
912		return ~~new MethodInvocation(e.getSpan(), true, e.getObj~~(),
913		~~e.getMethod(), e.getStaticArgs~~(),
914		e.getArg());
	984	return makeMethodInvocation(e.getSpan(), true, e.getExprType(),
	985	e.getObj(), e.getMethod(),
	986	e.getStaticArgs(), e.getArg());
915	987	}
916	988	public Expr forJuxt(Juxt e) {

trunk/ProjectFortress/src/com/sun/fortress/parser/Expression.rats

r3182	r3187
341	341	Expr receiver = ExprFactory.makeReceiver(IterUtil.skipLast(a1));
342	342	Span span = FortressUtil.spanTwo(receiver,a3);
343		Expr e1 = ~~new~~ MethodInvocation(span, receiver, last, a2, a3);
	343	Expr e1 = ExprFactory.makeMethodInvocation(span, receiver, last, a2, a3);
344	344	Expr e2 = (Expr)apply(a4s, e1);
345	345	yyValue = (Expr)apply(a5s, e2);
…	…
360	360	Expr receiver = ExprFactory.makeReceiver(IterUtil.skipLast(a1));
361	361	Span span = FortressUtil.spanTwo(receiver,a2);
362		Expr e1 = ~~new~~ MethodInvocation(span, receiver, last, a2);
	362	Expr e1 = ExprFactory.makeMethodInvocation(span, receiver, last, a2);
363	363	Expr e2 = (Expr)apply(a3s, e1);
364	364	yyValue = (Expr)apply(a4s, e2);
…	…
536	536	if (a2 == null) sargs = Collections.<StaticArg>emptyList();
537	537	else sargs = a2;
538		Expr mtdInv = ~~new~~ MethodInvocation(FortressUtil.spanTwo(base, a3),
539		~~false,~~ base, a1, sargs, a3);
	538	Expr mtdInv = ExprFactory.makeMethodInvocation(FortressUtil.spanTwo(base, a3),
	539	base, a1, sargs, a3);
540	540	return (Expr)apply(a4s, mtdInv);
541	541	}};

trunk/ProjectFortress/src/com/sun/fortress/parser/Literal.rats

r3032	r3187
55	55	{ if (a2s == null \|\| a2s.isEmpty()) {
56	56	List<ArrayExpr> list = new ArrayList<ArrayExpr>();
57		list.add(~~new ArrayElement(a1.getSpan(), false,~~ a1));
58		yyValue = ~~new ArrayElements(a1.getSpan(), false~~, 1, list);
	57	list.add(ExprFactory.makeArrayElement(a1));
	58	yyValue = ExprFactory.makeArrayElements(a1.getSpan(), 1, list);
59	59	} else
60	60	yyValue = FortressUtil.multiDimCons(a1, a2s.list());

trunk/ProjectFortress/src/com/sun/fortress/parser_util/FortressUtil.java

r3186	r3187
627	627	// (multi_dim_cons expr dim first :: rest))
628	628	private static ArrayExpr multiDimElement(Expr expr) {
629		return ~~new ArrayElement(expr.getSpan(), false,~~ expr);
	629	return ExprFactory.makeArrayElement(expr);
630	630	}
631	631	private static ArrayElements addOneMultiDim(ArrayExpr multi, int dim,
…	…
637	637	elems.add(multi);
638	638	elems.add(elem);
639		return ~~new ArrayElements(span, false~~, dim, elems);
	639	return ExprFactory.makeArrayElements(span, dim, elems);
640	640	} else if (multi instanceof ArrayElements) {
641	641	ArrayElements m = (ArrayElements)multi;
…	…
644	644	if (dim == _dim) {
645	645	elements.add(elem);
646		return ~~new ArrayElements(span, false~~, dim, elements);
	646	return ExprFactory.makeArrayElements(span, dim, elements);
647	647	} else if (dim > _dim) {
648	648	List<ArrayExpr> elems = new ArrayList<ArrayExpr>();
649	649	elems.add(multi);
650	650	elems.add(elem);
651		return ~~new ArrayElements(span, false~~, dim, elems);
	651	return ExprFactory.makeArrayElements(span, dim, elems);
652	652	} else if (elements.size() == 0) {
653	653	return syntaxError(multi.getSpan(),
…	…
657	657	ArrayExpr last = elements.get(index);
658	658	elements.set(index, addOneMultiDim(last, dim, expr));
659		return ~~new ArrayElements(span, false~~, _dim, elements);
	659	return ExprFactory.makeArrayElements(span, _dim, elements);
660	660	}
661	661	} else {
…	…
675	675	elems.add(_init);
676	676	elems.add(multiDimElement(expr));
677		ArrayElements result = ~~new ArrayElements(spanTwo(_init,expr), false~~,
678		pair.getA(), elems);
	677	ArrayElements result = ExprFactory.makeArrayElements(spanTwo(_init,expr),
	678	pair.getA(), elems);
679	679	for (Pair<Integer,Expr> _pair : rest.subList(1, rest.size())) {
680	680	int _dim = _pair.getA();
…	…
688	688
689	689	public static ArrayElements finalizeArrayExpr(ArrayElements a) {
690		return new ArrayElements(a.getSpan(), a.isParenthesized(),
691		a.getStaticArgs(), a.getDimension(),
692		a.getElements(), true);
	690	return ExprFactory.makeArrayElements(a, true);
693	691	}
694	692
695	693	public static ArrayElements addStaticArgsToArrayExpr(List<StaticArg> sargs,
696	694	ArrayElements a) {
697		return new ArrayElements(a.getSpan(), a.isParenthesized(),
698		sargs, a.getDimension(),
699		a.getElements(), true);
	695	return ExprFactory.makeArrayElements(a, sargs, true);
700	696	}
701	697

Context Navigation

Changeset 3187

Legend:

Download in other formats: