Context Navigation

← Previous Changeset
Next Changeset →

Changeset 3107

Timestamp:

11/26/08 11:47:16 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Eliminated subclasses of Param: NormalParam? and VarargsParam?

Location:

trunk/ProjectFortress

Files:

: 27 modified

astgen/Fortress.ast (modified) (3 diffs)
src/com/sun/fortress/compiler/IndexBuilder.java (modified) (1 diff)
src/com/sun/fortress/compiler/desugarer/DesugaringVisitor.java (modified) (3 diffs)
src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java (modified) (12 diffs)
src/com/sun/fortress/compiler/desugarer/VarRefContainer.java (modified) (4 diffs)
src/com/sun/fortress/compiler/disambiguator/SelfParamDisambiguator.java (modified) (3 diffs)
src/com/sun/fortress/compiler/index/FieldSetterMethod.java (modified) (2 diffs)
src/com/sun/fortress/compiler/typechecker/FnTypeEnv.java (modified) (2 diffs)
src/com/sun/fortress/compiler/typechecker/InferenceVarInserter.java (modified) (3 diffs)
src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (7 diffs)
src/com/sun/fortress/compiler/typechecker/TypeEnv.java (modified) (4 diffs)
src/com/sun/fortress/interpreter/evaluator/EvalType.java (modified) (1 diff)
src/com/sun/fortress/interpreter/evaluator/EvaluatorBase.java (modified) (3 diffs)
src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (1 diff)
src/com/sun/fortress/interpreter/rewrite/IsAnArrowName.java (modified) (2 diffs)
src/com/sun/fortress/nodes_util/ApiMaker.java (modified) (1 diff)
src/com/sun/fortress/nodes_util/ErrorMsgMaker.java (modified) (1 diff)
src/com/sun/fortress/nodes_util/NodeComparator.java (modified) (1 diff)
src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (3 diffs)
src/com/sun/fortress/nodes_util/NodeUtil.java (modified) (1 diff)
src/com/sun/fortress/parser/Method.rats (modified) (2 diffs)
src/com/sun/fortress/parser/MethodParam.rats (modified) (2 diffs)
src/com/sun/fortress/parser/Parameter.rats (modified) (7 diffs)
src/com/sun/fortress/parser/TraitObject.rats (modified) (3 diffs)
src/com/sun/fortress/parser_util/SyntaxChecker.java (modified) (1 diff)
src/com/sun/fortress/syntax_abstractions/phases/Transform.java (modified) (2 diffs)
src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/ProjectFortress/astgen/Fortress.ast

r3105	r3107
47	47	customPreprocessor com.sun.fortress.astgen.EllipsesNodeCreator;
48	48	customPreprocessor com.sun.fortress.astgen.TemplateGapNodeCreator;
49
50	49	customGenerator com.sun.fortress.astgen.UpdateVisitorGenerator;
51	50	customGenerator com.sun.fortress.astgen.TemplateVisitorGenerator;
…	…
54	53
55	54	customGenerator com.sun.fortress.astgen.FortressAstGenerator;
56
57	55
58	56	package com.sun.fortress.nodes;
…	…
643	641	* value parameter of functional declarations and object declarations
644	642	* Names must be unqualified.
645		*/
646		abstract Param(List<Modifier> mods = Collections.<Modifier>emptyList(),
647		Id name);
648		/**
649		* ValParam := BindId
650		* \| ( Params? )
651		* Params ::= (Param, )* (Varargs, )? Keyword(, Keyword)*
652		* \| (Param, )* Varargs
653		* \| Param(, Param)*
654		* Keyword ::= Param = Expr
655		* Param ::= BindId IsType?
656		* \| Type
657		* e.g.) x: ZZ32 = 3
658		* e.g.) self
659		*/
660		NormalParam(Option<Type> type = Option.<Type>none(),
661		Option<Expr> defaultExpr = Option.<Expr>none())
662		implements Lhs, ImplicitGetterSetter;
663		/**
664		* varargs parameter
665		* Varargs ::= BindId : Type ...
666		* e.g.) x: String...
667		*/
668		VarargsParam(Option<Type> varargsType = Option.<Type>none());
	643	* ValParam := BindId
	644	* \| ( Params? )
	645	* Params ::= (Param, )* (Varargs, )? Keyword(, Keyword)*
	646	* \| (Param, )* Varargs
	647	* \| Param(, Param)*
	648	* Keyword ::= Param = Expr
	649	* Param ::= BindId IsType?
	650	* \| Type
	651	* Varargs ::= BindId : Type ...
	652	* e.g.) x: ZZ32 = 3
	653	* e.g.) self
	654	* e.g.) x: String...
	655	*/
	656	Param(List<Modifier> mods = Collections.<Modifier>emptyList(),
	657	Id name,
	658	Option<Type> type = Option.<Type>none(),
	659	Option<Expr> defaultExpr = Option.<Expr>none(),
	660	Option<Type> varargsType = Option.<Type>none())
	661	implements Lhs, ImplicitGetterSetter;
669	662	/**
670	663	* expression

trunk/ProjectFortress/src/com/sun/fortress/compiler/IndexBuilder.java

r3096	r3107
327	327	fields.put(paramName, new ParamVariable(p));
328	328	if (!mods.isHidden) {
329		if ( p ~~instanceof NormalParam~~)
330		getters.put(paramName, new FieldGetterMethod(~~(NormalParam)~~p, name));
	329	if ( p.getVarargsType().isNone() )
	330	getters.put(paramName, new FieldGetterMethod(p, name));
331	331	else
332	332	bug(p, "Varargs object parameters should not define getters.");
333	333	}
334	334	if (mods.isSettable \|\| mods.isVar) {
335		if ( p ~~instanceof NormalParam~~)
336		setters.put(paramName, new FieldSetterMethod(~~(NormalParam)~~p, name));
	335	if ( p.getVarargsType().isNone() )
	336	setters.put(paramName, new FieldSetterMethod(p, name));
337	337	else
338	338	bug(p, "Varargs object parameters should not define setters.");

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

r3101	r3107
159	159	private static Option<List<Param>> mangleParams(Option<List<Param>> params) {
160	160	return new NodeUpdateVisitor() {
161		public Node forNormalParam(NormalParam that) {
162		return NodeFactory.makeParam(that, mangleName(that.getName()));
	161	public Node forParam(Param that) {
	162	if ( that.getVarargsType().isNone() )
	163	return NodeFactory.makeParam(that, mangleName(that.getName()));
	164	else
	165	return that;
163	166	}
164	167	}.recurOnOptionOfListOfParam(params);
…	…
173	176	if (params.isSome()) {
174	177	for (Param param: params.unwrap()) {
175		if (~~param instanceof NormalParam~~)
	178	if ( param.getVarargsType().isNone() )
176	179	newScope.add(param.getName());
177	180	}
…	…
316	319	if (params.isSome()) {
317	320	for (Param param : params.unwrap()) {
318		if (param instanceof NormalParam) {
319		NormalParam _param = (NormalParam)param;
320		if (! hidden(_param) &&
321		! hasExplicitGetter(_param.getName(), decls))
322		result.add(makeGetter(false, owner, _param));
323		if ((settable(_param) \|\| mutable(_param)) &&
324		! hasExplicitSetter(_param.getName(), decls)) {
325		result.add(makeSetter(false, owner, _param));
	321	if ( param.getVarargsType().isNone() ) {
	322	if (! hidden(param) &&
	323	! hasExplicitGetter(param.getName(), decls))
	324	result.add(makeGetter(false, owner, param));
	325	if ((settable(param) \|\| mutable(param)) &&
	326	! hasExplicitSetter(param.getName(), decls)) {
	327	result.add(makeSetter(false, owner, param));
326	328	}
327	329	}

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

r3102	r3107
393	393	* expression captured mutable variables (they would be boxed).
394	394	* We only store the function id and type pair as value because
395		* that's all we need. If we store the ~~Normal~~Param instead, we
	395	* that's all we need. If we store the Param instead, we
396	396	* would have to dig those info out again.
397	397	*/
…	…
594	594	exit.getExprType(), exit.getTarget(), var);
595	595	exitFnExprParams.add(
596		NodeFactory.make~~Normal~~Param(exitSpan,
	596	NodeFactory.makeParam(exitSpan,
597	597	exitWithId, exitWithTypeOp) );
598	598	} else {
…	…
641	641
642	642	Option<List<Param>> params = null;
643		~~Normal~~Param enclosingSelf = null;
	643	Param enclosingSelf = null;
644	644
645	645	List<StaticParam> staticParams =
…	…
663	663
664	664	if(enclosingSelf != null) {
665		VarRef receiver = makeVarRefFrom~~Normal~~Param(enclosingSelf);
	665	VarRef receiver = makeVarRefFromParam(enclosingSelf);
666	666	DottedMethodRewriteVisitor rewriter =
667	667	new DottedMethodRewriteVisitor(receiver, freeMethodRefs);
…	…
718	718	makeParamsForLiftedObj(ObjectExpr target,
719	719	FreeNameCollection freeNames,
720		~~Normal~~Param enclosingSelfParam,
	720	Param enclosingSelfParam,
721	721	Map<Pair<Span,Id>,Pair<Id,Type>> exitFnParamMap) {
722	722
723	723	Option<Type> type = null;
724		~~Normal~~Param param = null;
	724	Param param = null;
725	725	List<Param> params = new LinkedList<Param>();
726	726	List<VarRef> freeVarRefs = freeNames.getFreeVarRefs();
…	…
745	745	// FIXME: what span should I use?
746	746	type = var.getExprType();
747		param = NodeFactory.make~~Normal~~Param(var.getSpan(),
	747	param = NodeFactory.makeParam(var.getSpan(),
748	748	var.getVar(), type);
749	749	params.add(param);
…	…
758	758	// FIXME: what span should I use?
759	759	type = fn.getExprType();
760		param = NodeFactory.make~~Normal~~Param(fn.getSpan(),
	760	param = NodeFactory.makeParam(fn.getSpan(),
761	761	fn.getOriginalName(), type);
762	762	params.add(param);
…	…
787	787	Id exitFnId = NodeFactory.makeId(exitSpan,
788	788	MANGLE_CHAR + EXIT_FUNC_PREFIX + "_" + exitIndex);
789		param = NodeFactory.make~~Normal~~Param(exitSpan, exitFnId, type);
	789	param = NodeFactory.makeParam(exitSpan, exitFnId, type);
790	790	params.add(param);
791	791	Pair<Span, Id> exitKey = new Pair<Span,Id>(exitSpan, label);
…	…
804	804
805	805
806		private ~~Normal~~Param makeEnclosingSelfParam(Span paramSpan,
	806	private Param makeEnclosingSelfParam(Span paramSpan,
807	807	Option<Type> enclosingSelfType) {
808		~~Normal~~Param param = null;
	808	Param param = null;
809	809
810	810	// Just sanity check
…	…
817	817	Id enclosingParamId = NodeFactory.makeId(paramSpan,
818	818	MANGLE_CHAR + ENCLOSING_PREFIX + "_" + objExprNestingLevel);
819		param = NodeFactory.make~~Normal~~Param(paramSpan,
	819	param = NodeFactory.makeParam(paramSpan,
820	820	enclosingParamId, enclosingSelfType);
821	821
…	…
880	880	}
881	881
882		private VarRef makeVarRefFrom~~NormalParam(Normal~~Param param) {
	882	private VarRef makeVarRefFromParam(Param param) {
883	883	VarRef varRef = ExprFactory.makeVarRef( param.getSpan(),
884	884	param.getName(),
…	…
1021	1021	// Option<Node> declNodeOp =
1022	1022	// typeEnv.declarationSite( varRef.getVar() );
1023		// ~~Normal~~Param param = null;
	1023	// Param param = null;
1024	1024	// if( declNodeOp.isSome() ) {
1025	1025	// param = makeVarParamFromVarRef( varRef,

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

r3102	r3107
32	32	import com.sun.fortress.nodes.ModifierSettable;
33	33	import com.sun.fortress.nodes.Node;
34		~~import com.sun.fortress.nodes.NormalParam;~~
35	34	import com.sun.fortress.nodes.ObjectDecl;
36	35	import com.sun.fortress.nodes.Param;
…	…
92	91	public ObjectDecl containerDecl() {
93	92	List<Param> params = new LinkedList<Param>();
94		~~Normal~~Param param = makeVarParamFromVarRef( origVar,
	93	Param param = makeVarParamFromVarRef( origVar,
95	94	origDeclNode.getSpan(), origVar.getExprType() );
96	95	params.add(param);
…	…
107	106	}
108	107
109		public ~~Normal~~Param containerTypeParam() {
110		return new ~~Normal~~Param( origDeclNode.getSpan(),
111		containerVarId(), containerType() );
	108	public Param containerTypeParam() {
	109	return new Param( origDeclNode.getSpan(),
	110	containerVarId(), containerType() );
112	111	}
113	112
…	…
146	145	}
147	146
148		private ~~Normal~~Param makeVarParamFromVarRef(VarRef var,
	147	private Param makeVarParamFromVarRef(VarRef var,
149	148	Span paramSpan,
150	149	Option<Type> typeOp) {
151	150	List<Modifier> mods = new LinkedList<Modifier>();
152	151	mods.add( new ModifierSettable(paramSpan) );
153		~~NormalParam param = new Normal~~Param(paramSpan, mods,
154		var.getVar(), typeOp);
	152	Param param = new Param(paramSpan, mods,
	153	var.getVar(), typeOp);
155	154	return param;
156	155	}

trunk/ProjectFortress/src/com/sun/fortress/compiler/disambiguator/SelfParamDisambiguator.java

r3096	r3107
28	28	import com.sun.fortress.nodes.Node;
29	29	import com.sun.fortress.nodes.NodeUpdateVisitor;
30		~~import com.sun.fortress.nodes.NormalParam;~~
31	30	import com.sun.fortress.nodes.ObjectDecl;
32	31	import com.sun.fortress.nodes.ObjectExpr;
	32	import com.sun.fortress.nodes.Param;
33	33	import com.sun.fortress.nodes.TraitDecl;
34	34	import com.sun.fortress.nodes.Type;
…	…
93	93	int traitNestingDepth = 0;
94	94	@Override
95		public Node forNormalParamOnly(NormalParam that,
96		List<Modifier> mods_result, Id name_result,
97		Option<Type> type_result, Option<Expr> defaultExpr_result) {
	95	public Node forParamOnly(Param that,
	96	List<Modifier> mods_result, Id name_result,
	97	Option<Type> type_result,
	98	Option<Expr> defaultExpr_result,
	99	Option<Type> varargsType_result) {
	100	if ( varargsType_result.isNone() ) {
98	101	// my type is broken I need to qualify the type name
99	102	Option<Type> new_type;
…	…
103	106	new_type = type_result;
104	107
105		return new NormalParam(that.getSpan(),
106		that.getMods(),
107		that.getName(),
108		new_type,
109		that.getDefaultExpr());
110		}
	108	return new Param(that.getSpan(),
	109	that.getMods(),
	110	that.getName(),
	111	new_type,
	112	that.getDefaultExpr(),
	113	that.getVarargsType());
	114	} else
	115	return that;
	116	}
111	117
112	118	// end recurrance here

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/FieldSetterMethod.java

r2600	r3107
29	29	import com.sun.fortress.nodes.Modifier;
30	30	import com.sun.fortress.nodes.NodeUpdateVisitor;
31		~~import com.sun.fortress.nodes.NormalParam;~~
32	31	import com.sun.fortress.nodes.Param;
33	32	import com.sun.fortress.nodes.StaticArg;
…	…
59	58	public List<Param> parameters() {
60	59	// return the implicit parameter
61		Param p = new ~~NormalParam(_ast.getSpan(), Collections.<Modifier>emptyList(),~~
62		new Id(_ast.getSpan(), "fakeParamForImplicitSetter"), _ast.getType(),
63		Option.<Expr>none());
	60	Param p = new Param(_ast.getSpan(), Collections.<Modifier>emptyList(),
	61	new Id(_ast.getSpan(), "fakeParamForImplicitSetter"), _ast.getType(),
	62	Option.<Expr>none());
64	63	return Collections.singletonList(p);
65	64	}

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

r3099	r3107
40	40	import com.sun.fortress.nodes.IntersectionType;
41	41	import com.sun.fortress.nodes.Node;
42		~~import com.sun.fortress.nodes.NormalParam;~~
43	42	import com.sun.fortress.nodes.Param;
44	43	import com.sun.fortress.nodes.StaticArg;
…	…
86	85	for( Param param : fn.getParams() ) {
87	86	if( param.getName().equals(IndexBuilder.SELF_NAME) ) {
88		~~if( param instanceof NormalParam~~ )
89		self_type_ = ~~((NormalParam)param)~~.getType();
	87	if( param.getVarargsType().isNone() )
	88	self_type_ = param.getType();
90	89	else
91	90	InterpreterBug.bug("self cannot be a varargs.");

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

r3105	r3107
29	29	import com.sun.fortress.nodes.Node;
30	30	import com.sun.fortress.nodes.NodeUpdateVisitor;
31		~~import com.sun.fortress.nodes.NormalParam;~~
32	31	import com.sun.fortress.nodes.Param;
33	32	import com.sun.fortress.nodes.StaticParam;
…	…
80	79
81	80	@Override
82		public Node forNormalParamOnly(NormalParam that,
83		List<Modifier> mods_result, Id name_result,
84		Option<Type> type_result, Option<Expr> defaultExpr_result) {
	81	public Node forParamOnly(Param that,
	82	List<Modifier> mods_result, Id name_result,
	83	Option<Type> type_result,
	84	Option<Expr> defaultExpr_result,
	85	Option<Type> varargsType_result) {
	86	if ( varargsType_result.isNone() ) {
85	87	// Is the type given?
86	88	Option<Type> new_type =
…	…
89	91	type_result;
90	92
91		return super.forNormalParamOnly(that, mods_result, name_result, new_type,
92		defaultExpr_result);
	93	return super.forParamOnly(that, mods_result, name_result, new_type,
	94	defaultExpr_result, varargsType_result);
	95	} else
	96	return that;
93	97	}
94	98	}

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

r3105	r3107
247	247
248	248	public LinkedList<Type> value(LinkedList<Type> arg0, Param arg1) {
249		~~if( arg1 instanceof NormalParam~~ ) {
	249	if( arg1.getVarargsType().isNone() ) {
250	250	typeCount++;
251		arg0.add(~~((NormalParam)arg1)~~.getType().unwrap());
	251	arg0.add(arg1.getType().unwrap());
252	252	return arg0;
253	253	}
254		~~else { // VarargP~~aram, add until the sizes are equal
	254	else { // a varargs param, add until the sizes are equal
255	255	int to_add = arg_size - typeCount;
256	256	while( to_add > 0 ) {
257		arg0.add(~~((VarargsParam)arg1)~~.getVarargsType().unwrap());
	257	arg0.add(arg1.getVarargsType().unwrap());
258	258	to_add--;
259	259	}
…	…
263	263
264	264	//handle defaults (nyi)
265		if(params.get(params.size()-1) ~~instanceof NormalParam~~
266		~~&& ((NormalParam)params.get(params.size()-1)~~).getDefaultExpr().isSome()){
	265	if(params.get(params.size()-1).getVarargsType().isNone()
	266	&& params.get(params.size()-1).getDefaultExpr().isSome()){
267	267	return NI.nyi();
268	268	}
…	…
617	617	field_node.accept(new NodeAbstractVisitor<Type>() {
618	618	@Override
619		public Type forNormalParam(NormalParam that) { return that.getType().unwrap(); }
620
621		@Override
622		public Type forVarargsParam(VarargsParam that) { return that.getVarargsType().unwrap(); }
	619	public Type forParam(Param that) {
	620	if ( that.getVarargsType().isNone() )
	621	return that.getType().unwrap();
	622	else
	623	return that.getVarargsType().unwrap();
	624	}
623	625	});
624	626
…	…
1432	1434
1433	1435	@Override
1434		public Pair<TypeCheckerResult, Type> forNormalParam(NormalParam that) {
	1436	public Pair<TypeCheckerResult, Type> forParam(Param that) {
	1437	if ( that.getVarargsType().isNone() ) {
1435	1438	if( !NodeUtil.isMutable(that) ) {
1436	1439	String err = "Left-hand side of assignment must be mutable.";
…	…
1444	1447	lhs_type);
1445	1448	}
	1449	} else
	1450	return bug(that, "Varargs parameter should not appear in the left-hand side of an assignment.");
1446	1451	}
1447	1452
…	…
2378	2383	Boolean varargs=false;
2379	2384	for(Param p: that.getParams()){
2380		if(p instanceof NormalParam){
2381		NormalParam n = (NormalParam)p;
2382		if(n.getType().isSome()){
2383		dlist.add(n.getType().unwrap());
2384		}
2385		else{
2386		NI.nyi();
2387		}
2388		}
2389		if(p instanceof VarargsParam){
2390		VarargsParam v = (VarargsParam) p;
2391		dlist.add(v.getVarargsType().unwrap());
2392		varargs=true;
2393		}
	2385	if(p.getVarargsType().isNone()){
	2386	if(p.getType().isSome()){
	2387	dlist.add(p.getType().unwrap());
	2388	}
	2389	else{
	2390	NI.nyi();
	2391	}
	2392	} else {
	2393	dlist.add(p.getVarargsType().unwrap());
	2394	varargs=true;
	2395	}
2394	2396	}
2395	2397	AbstractTupleType domain;
…	…
3356	3358
3357	3359	@Override
3358		public TypeCheckerResult for~~NormalParam(Normal~~Param that) {
3359		// No checks needed to be performed on a ~~Normal~~Param.
	3360	public TypeCheckerResult forParam(Param that) {
	3361	// No checks needed to be performed on a Param.
3360	3362	return new TypeCheckerResult(that);
3361	3363	}

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

r3105	r3107
66	66	import com.sun.fortress.nodes.NodeAbstractVisitor;
67	67	import com.sun.fortress.nodes.NodeDepthFirstVisitor;
68		~~import com.sun.fortress.nodes.NormalParam;~~
69	68	import com.sun.fortress.nodes.Op;
70	69	import com.sun.fortress.nodes.OpArg;
…	…
79	78	import com.sun.fortress.nodes.UnitParam;
80	79	import com.sun.fortress.nodes.UnitRef;
81		~~import com.sun.fortress.nodes.VarargsParam;~~
82	80	import com.sun.fortress.nodes._InferenceVarType;
83	81	import com.sun.fortress.nodes._RewriteGenericArrowType;
…	…
133	131	*/
134	132	protected static Option<Type> typeFromParam(Param param) {
135		if (param instanceof NormalParam) {
136		NormalParam _param = (NormalParam) param;
137		return _param.getType();
138		} else { // param instanceof VarargsParam
	133	if (param.getVarargsType().isNone()) {
	134	return param.getType();
	135	} else { // a varargs param
139	136	// Convert the declared varargs type into a reference to
140	137	// FortressBuiltin.ImmutableHeapSequence.
141		VarargsParam _param = (VarargsParam) param;
142
143		Type result = Types.makeVarargsParamType(_param.getVarargsType().unwrap());
	138	Type result = Types.makeVarargsParamType(param.getVarargsType().unwrap());
144	139	return some(result);
145	140	}
…	…
166	161
167	162	for (Param param: params) {
168		if (param instanceof NormalParam) {
169		NormalParam _param = (NormalParam) param;
170		Option<Type> maybeType = _param.getType();
	163	if (param.getVarargsType().isNone()) {
	164	Option<Type> maybeType = param.getType();
171	165
172	166	if (maybeType.isSome()) { // An explicit type is declared.
173		if (_param.getDefaultExpr().isSome()) { // We have a keyword param.
174		keywordTypes.add(makeKeywordType(_param.getName(), maybeType.unwrap()));
	167	if (param.getDefaultExpr().isSome()) { // We have a keyword param.
	168	keywordTypes.add(makeKeywordType(param.getName(), maybeType.unwrap()));
175	169	} else { // We have an ordinary param.
176	170	paramTypes.add(maybeType.unwrap());
177	171	}
178	172	} else { // No type is explicitly declared for this parameter.
179		if (_param.getDefaultExpr().isSome()) { // We have a keyword param.
180		keywordTypes.add(makeKeywordType(~~_param.getName(), NodeFactory.make_InferenceVarType(_~~param.getSpan())));
	173	if (param.getDefaultExpr().isSome()) { // We have a keyword param.
	174	keywordTypes.add(makeKeywordType(param.getName(), NodeFactory.make_InferenceVarType(param.getSpan())));
181	175	} else { // We have an ordinary param.
182		paramTypes.add(NodeFactory.make_InferenceVarType(_param.getSpan()));
	176	paramTypes.add(NodeFactory.make_InferenceVarType(param.getSpan()));
183	177	}
184	178	}
185	179	} else { // We have a varargs param.
186		VarargsParam _param = (VarargsParam) param;
187		varargsType = some(_param.getVarargsType().unwrap());
	180	varargsType = some(param.getVarargsType().unwrap());
188	181	}
189	182	}

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/EvalType.java

r3105	r3107
170	170	String pname = NodeUtil.nameString(idName);
171	171	FType ptype;
172		if (in_p ~~instanceof NormalParam~~) {
173		Option<Type> type = ~~((NormalParam)in_p)~~.getType();
	172	if (in_p.getVarargsType().isNone()) {
	173	Option<Type> type = in_p.getType();
174	174	ptype = e.getFTypeFromOption(type, FTypeTop.ONLY);
175	175	}
176		else { // ~~in_p instanceof VarargsP~~aram
177		ptype = FTypeRest.make(e.getFType(~~((VarargsParam)in_p)~~.getVarargsType().unwrap()));
	176	else { // a varargs param
	177	ptype = FTypeRest.make(e.getFType(in_p.getVarargsType().unwrap()));
178	178	}
179	179	Parameter fp = new Parameter(pname, ptype, NodeUtil.isMutable(in_p));

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/EvaluatorBase.java

r3105	r3107
180	180	Param pa = pit.next();
181	181
182		if ( ~~! (pa instanceof VarargsParam)~~) {
	182	if ( pa.getVarargsType().isNone() ) {
183	183	/* Tuple (or even re-tuple) arguments when inferring type
184	184	* if passing different # of args to 1-arg function. */
…	…
207	207	}
208	208	try {
209		if (p ~~instanceof NormalParam~~) {
210		Option<Type> t = ~~((NormalParam) p)~~.getType();
	209	if (p.getVarargsType().isNone()) {
	210	Option<Type> t = p.getType();
211	211	// why can't we just skip if missing?
212	212	if (t.isNone()) {
…	…
237	237	at.unify(e, tp_set, abm, ty);
238	238	}
239		} else { // ~~p instanceof VarargsP~~aram
240		Type ty = ~~((VarargsParam) p)~~.getVarargsType().unwrap();
	239	} else { // a varargs param
	240	Type ty = p.getVarargsType().unwrap();
241	241	if (DUMP_INFERENCE)
242	242	System.err.println("Unifying "+at+" and vararg type "+ty);

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

r3105	r3107
86	86	import com.sun.fortress.nodes.NodeAbstractVisitor;
87	87	import com.sun.fortress.nodes.NodeAbstractVisitor_void;
88		~~import com.sun.fortress.nodes.NormalParam;~~
89	88	import com.sun.fortress.nodes.ObjectDecl;
90	89	import com.sun.fortress.nodes.ObjectExpr;

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

r3095	r3107
22	22	import com.sun.fortress.nodes.Node;
23	23	import com.sun.fortress.nodes.NodeAbstractVisitor;
24		import com.sun.fortress.nodes.~~Normal~~Param;
	24	import com.sun.fortress.nodes.Param;
25	25	import com.sun.fortress.nodes.TestDecl;
26	26	import com.sun.fortress.nodes.Type;
27		~~import com.sun.fortress.nodes.VarargsParam;~~
28	27	import com.sun.fortress.nodes_util.NodeUtil;
29	28
…	…
72	71
73	72	/* (non-Javadoc)
74		* @see com.sun.fortress.nodes.NodeAbstractVisitor#for~~NormalParam(com.sun.fortress.nodes.Normal~~Param)
	73	* @see com.sun.fortress.nodes.NodeAbstractVisitor#forParam(com.sun.fortress.nodes.Param)
75	74	*/
76	75	@Override
77		public ArrowOrFunctional forNormalParam(NormalParam that) {
78		return optionTypeIsArrow(that.getType());
79		}
80
81		/* (non-Javadoc)
82		* @see com.sun.fortress.nodes.NodeAbstractVisitor#forVarargsParam(com.sun.fortress.nodes.VarargsParam)
83		*/
84		@Override
85		public ArrowOrFunctional forVarargsParam(VarargsParam that) {
86		return ArrowOrFunctional.NEITHER;
	76	public ArrowOrFunctional forParam(Param that) {
	77	if ( that.getVarargsType().isNone() )
	78	return optionTypeIsArrow(that.getType());
	79	else
	80	return ArrowOrFunctional.NEITHER;
87	81	}
88	82

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

r3102	r3107
181	181	log(that, "The return type of " + that.getName() + " is required.");
182	182	for ( Param p : that.getParams() ) {
183		if ( p instanceof NormalParam &&
184		((NormalParam)p).getType().isNone() &&
	183	if ( p.getType().isNone() &&
185	184	! p.getName().getText().equals("self") )
186	185	log(p, "The type of " + p.getName() + " is required.");

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

r3105	r3107
317	317	}
318	318
319		public String for~~NormalParam(Normal~~Param node) {
	319	public String forParam(Param node) {
320	320	StringBuffer sb = new StringBuffer();
321	321	sb.append(NodeUtil.nameString(node.getName()));
322		if (node.getType().isSome()) {
	322	if ( node.getVarargsType().isNone() ) {
	323	if (node.getType().isSome()) {
	324	sb.append(":");
	325	sb.append(node.getType().unwrap().accept(this));
	326	}
	327	if (node.getDefaultExpr().isSome()) {
	328	sb.append("=");
	329	sb.append(node.getDefaultExpr().unwrap().accept(this));
	330	}
	331	} else {
323	332	sb.append(":");
324		sb.append(node.getType().unwrap().accept(this));
325		}
326		if (node.getDefaultExpr().isSome()) {
327		sb.append("=");
328		sb.append(node.getDefaultExpr().unwrap().accept(this));
329		}
330		return sb.toString();
331		}
332
333		public String forVarargsParam(VarargsParam node) {
334		StringBuffer sb = new StringBuffer();
335		sb.append(NodeUtil.nameString(node.getName()));
336		sb.append(":");
337		sb.append(node.getVarargsType().unwrap().accept(this));
338		sb.append("...");
339
	333	sb.append(node.getVarargsType().unwrap().accept(this));
	334	sb.append("...");
	335	}
340	336	return sb.toString();
341	337	}

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

r3105	r3107
211	211	.compareTo(NodeUtil.nameString(right.getName()));
212	212	if (x != 0) return x;
213		if ((left ~~instanceof NormalParam) && (right instanceof NormalParam~~)) {
214		x = compareOptionalType(~~((NormalParam)left).getType(), ((NormalParam)right)~~.getType());
215		}
216		if ((left ~~instanceof VarargsParam) && (right instanceof VarargsParam~~)) {
217		x = compareOptionalType(~~((VarargsParam)left).getVarargsType(), ((VarargsParam)right)~~.getVarargsType());
	213	if ((left.getVarargsType().isNone()) && (right.getVarargsType().isNone())) {
	214	x = compareOptionalType(left.getType(), right.getType());
	215	}
	216	if ((left.getVarargsType().isSome()) && (right.getVarargsType().isSome())) {
	217	x = compareOptionalType(left.getVarargsType(), right.getVarargsType());
218	218	}
219	219	if (x != 0) return x;

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

r3105	r3107
824	824	}
825	825
826		public static LValue makeLValue(~~Normal~~Param param) {
	826	public static LValue makeLValue(Param param) {
827	827	return new LValue(param.getSpan(), param.getName(),
828	828	param.getType(), param.getMods(), false);
…	…
952	952	}
953	953
954		public static VarargsParam makeVarargsParam(Id name, Type type) {
955		return new VarargsParam(name.getSpan(), Collections.<Modifier>emptyList(),
956		name, Option.<Type>some(type));
957		}
958
959		public static VarargsParam makeVarargsParam(VarargsParam param, List<Modifier> mods) {
960		return new VarargsParam(param.getSpan(), mods, param.getName(), param.getVarargsType());
961		}
962
963		public static VarargsParam makeVarargsParam(Span span, List<Modifier> mods,
964		Id name, Type type) {
965		return new VarargsParam(span, mods, name, Option.<Type>some(type));
966		}
967
968		public static NormalParam makeAbsParam(Type type) {
	954	public static Param makeVarargsParam(Id name, Type type) {
	955	return new Param(name.getSpan(), Collections.<Modifier>emptyList(),
	956	name, Option.<Type>none(), Option.<Expr>none(), Option.<Type>some(type));
	957	}
	958
	959	public static Param makeVarargsParam(Param param, List<Modifier> mods) {
	960	return new Param(param.getSpan(), mods, param.getName(),
	961	Option.<Type>none(), Option.<Expr>none(),
	962	param.getVarargsType());
	963	}
	964
	965	public static Param makeVarargsParam(Span span, List<Modifier> mods,
	966	Id name, Type type) {
	967	return new Param(span, mods, name,
	968	Option.<Type>none(), Option.<Expr>none(),
	969	Option.<Type>some(type));
	970	}
	971
	972	public static Param makeAbsParam(Type type) {
969	973	Id id = new Id(type.getSpan(), "_");
970		return new ~~Normal~~Param(type.getSpan(), Collections.<Modifier>emptyList(),
971		id, Option.some(type), Option.<Expr>none());
972		}
973
974		public static ~~Normal~~Param makeParam(Span span, List<Modifier> mods, Id name,
975		Type type) {
976		return new ~~Normal~~Param(span, mods, name, Option.some(type), Option.<Expr>none());
977		}
978
979		public static ~~Normal~~Param makeParam(Span span, List<Modifier> mods, Id name,
980		Option<Type> type) {
981		return new ~~Normal~~Param(span, mods, name, type, Option.<Expr>none());
982		}
983
984		public static ~~Normal~~Param makeParam(Id id, Type type) {
985		return new ~~Normal~~Param(id.getSpan(), Collections.<Modifier>emptyList(),
986		id, Option.some(type), Option.<Expr>none());
987		}
988
989		public static ~~Normal~~Param makeParam(Id name) {
990		return new ~~Normal~~Param(name.getSpan(), Collections.<Modifier>emptyList(),
991		name, Option.<Type>none(), Option.<Expr>none());
992		}
993
994		public static ~~NormalParam makeParam(Normal~~Param param, Expr expr) {
995		return new ~~Normal~~Param(param.getSpan(), param.getMods(), param.getName(),
996		param.getType(), Option.some(expr));
997		}
998
999		public static ~~NormalParam makeParam(Normal~~Param param, List<Modifier> mods) {
1000		return new ~~Normal~~Param(param.getSpan(), mods, param.getName(),
1001		param.getType(), param.getDefaultExpr());
1002		}
1003
1004		public static ~~NormalParam makeParam(Normal~~Param param, Id newId) {
1005		return new ~~Normal~~Param(param.getSpan(), param.getMods(), newId,
1006		param.getType(), param.getDefaultExpr());
	974	return new Param(type.getSpan(), Collections.<Modifier>emptyList(),
	975	id, Option.some(type), Option.<Expr>none());
	976	}
	977
	978	public static Param makeParam(Span span, List<Modifier> mods, Id name,
	979	Type type) {
	980	return new Param(span, mods, name, Option.some(type), Option.<Expr>none());
	981	}
	982
	983	public static Param makeParam(Span span, List<Modifier> mods, Id name,
	984	Option<Type> type) {
	985	return new Param(span, mods, name, type, Option.<Expr>none());
	986	}
	987
	988	public static Param makeParam(Id id, Type type) {
	989	return new Param(id.getSpan(), Collections.<Modifier>emptyList(),
	990	id, Option.some(type), Option.<Expr>none());
	991	}
	992
	993	public static Param makeParam(Id name) {
	994	return new Param(name.getSpan(), Collections.<Modifier>emptyList(),
	995	name, Option.<Type>none(), Option.<Expr>none());
	996	}
	997
	998	public static Param makeParam(Param param, Expr expr) {
	999	return new Param(param.getSpan(), param.getMods(), param.getName(),
	1000	param.getType(), Option.some(expr));
	1001	}
	1002
	1003	public static Param makeParam(Param param, List<Modifier> mods) {
	1004	return new Param(param.getSpan(), mods, param.getName(),
	1005	param.getType(), param.getDefaultExpr());
	1006	}
	1007
	1008	public static Param makeParam(Param param, Id newId) {
	1009	return new Param(param.getSpan(), param.getMods(), newId,
	1010	param.getType(), param.getDefaultExpr());
1007	1011	}
1008	1012
…	…
1049	1053	}
1050	1054
1051		public static ~~NormalParam makeNormal~~Param(Span span, Id name, Option<Type> type) {
1052		return new ~~Normal~~Param(span, name, type);
	1055	public static Param makeParam(Span span, Id name, Option<Type> type) {
	1056	return new Param(span, name, type);
1053	1057	}
1054	1058

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

r3096	r3107
155	155	public static boolean isMultifix(List<Param> params) {
156	156	for (Param p : params) {
157		if (p instanceof VarargsParam) return true;
	157	if ( p.getVarargsType().isSome() )
	158	return true;
158	159	}
159	160	return (params.size() > 2);

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

r3095	r3107
154	154	a4:CoercionClauses w a5:(widens w)? equals w a6:NoNewlineExpr
155	155	{ if (a1 == null) a1 = FortressUtil.emptyStaticParams();
156		List<Param> params = FortressUtil.<Param, ~~Normal~~Param>mkList(NodeFactory.makeParam(a2, a3));
	156	List<Param> params = FortressUtil.<Param, Param>mkList(NodeFactory.makeParam(a2, a3));
157	157	List<Modifier> mods = new ArrayList<Modifier>();
158	158	if (a5 != null) mods.add(new ModifierWidens(createSpan(yyStart,8)));
…	…
169	169	a4:CoercionClauses a5:(w widens)?
170	170	{ if (a1 == null) a1 = FortressUtil.emptyStaticParams();
171		List<Param> params = FortressUtil.<Param, ~~Normal~~Param>mkList(NodeFactory.makeParam(a2, a3));
	171	List<Param> params = FortressUtil.<Param, Param>mkList(NodeFactory.makeParam(a2, a3));
172	172	List<Modifier> mods = new ArrayList<Modifier>();
173	173	if (a5 != null) mods.add(new ModifierWidens(createSpan(yyStart,8)));

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

r2598	r3107
48	48	};
49	49
50		~~Normal~~Param Param :=
	50	Param Param :=
51	51	PlainParam
52	52	/ a1:self
…	…
54	54	"self")); };
55	55
56		~~Normal~~Param AbsParam :=
	56	Param AbsParam :=
57	57	a1:self
58	58	{ yyValue = NodeFactory.makeParam(new Id(createSpan(yyStart,yyCount),

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

r2845	r3107
35	35	transient List<Param> ValParam =
36	36	a1:BindId
37		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(NodeFactory.makeParam(a1)); }
	37	{ yyValue = FortressUtil.<Param, Param>mkList(NodeFactory.makeParam(a1)); }
38	38	/ openparen a1:(w Params)? w closeparen
39	39	{ if (a1 == null) yyValue = FortressUtil.emptyParams();
…	…
48	48	}
49	49	/ a1:Type
50		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(NodeFactory.makeAbsParam(a1)); };
	50	{ yyValue = FortressUtil.<Param, Param>mkList(NodeFactory.makeAbsParam(a1)); };
51	51
52	52	/* Params ::=
…	…
73	73	/ a1s:(Param w comma w)* a2:(Varargs w comma w)? a3:Keyword
74	74	a4s:(w comma w Keyword)*
75		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(a1s.list());
	75	{ yyValue = FortressUtil.<Param, Param>mkList(a1s.list());
76	76	if (a2 != null) yyValue.add(a2);
77	77	yyValue.add(a3);
…	…
79	79	}
80	80	/ a1s:(Param w comma w)* a2:Varargs
81		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(a1s.list(), a2); }
	81	{ yyValue = FortressUtil.<Param, Param>mkList(a1s.list(), a2); }
82	82	/ a1:Param a2s:(w comma w Param)*
83		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(a1, a2s.list()); };
	83	{ yyValue = FortressUtil.<Param, Param>mkList(a1, a2s.list()); };
84	84
85	85	/* AbsParams ::=
…	…
106	106	/ a1s:(AbsParam w comma w)* a2:(Varargs w comma w)? a3:Keyword
107	107	a4s:(w comma w Keyword)*
108		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(a1s.list());
	108	{ yyValue = FortressUtil.<Param, Param>mkList(a1s.list());
109	109	if (a2 != null) yyValue.add(a2);
110	110	yyValue.add(a3);
…	…
112	112	}
113	113	/ a1s:(AbsParam w comma w)* a2:Varargs
114		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(a1s.list(), a2); }
	114	{ yyValue = FortressUtil.<Param, Param>mkList(a1s.list(), a2); }
115	115	/ a1:AbsParam a2s:(w comma w AbsParam)*
116		{ yyValue = FortressUtil.<Param, ~~Normal~~Param>mkList(a1, a2s.list()); };
	116	{ yyValue = FortressUtil.<Param, Param>mkList(a1, a2s.list()); };
117	117
118	118	/* Varargs ::= BindId w : w Type w ... */
119		transient ~~Varargs~~Param VarargsParam = a1:BindId w colon w a2:Type w ellipses
	119	transient Param VarargsParam = a1:BindId w colon w a2:Type w ellipses
120	120	{ yyValue = NodeFactory.makeVarargsParam(a1, a2); };
121		transient ~~Varargs~~Param Varargs = VarargsParam ;
	121	transient Param Varargs = VarargsParam ;
122	122
123	123	/* Keyword ::= Param w = w Expr */
…	…
126	126
127	127	/* Param ::= BindId (w IsType)? */
128		transient ~~Normal~~Param PlainParam =
	128	transient Param PlainParam =
129	129	a1:BindId a2:(w IsType)?
130	130	{ if (a2 != null) yyValue = NodeFactory.makeParam(a1, a2);
131	131	else yyValue = NodeFactory.makeParam(a1);
132	132	};
133		transient ~~Normal~~Param Param = PlainParam ;
	133	transient Param Param = PlainParam ;
134	134
135	135	/* AbsParam ::= BindId w IsType \| Type */
136		transient ~~Normal~~Param AbsPlainParam =
	136	transient Param AbsPlainParam =
137	137	a1:BindId w a2:IsType
138	138	{ yyValue = NodeFactory.makeParam(a1, a2); }
139	139	/ a1:Type
140	140	{ yyValue = NodeFactory.makeAbsParam(a1); };
141		transient ~~Normal~~Param AbsParam = AbsPlainParam ;
	141	transient Param AbsParam = AbsPlainParam ;
142	142
143	143	/* OpHeaderFront ::=

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

r3098	r3107
215	215	ObjectParam ::= ParamFldMods? Param
216	216	*/
217		~~Varargs~~Param Varargs :=
	217	Param Varargs :=
218	218	<ErrorProduction>
219	219	VarargsParam
…	…
222	222	};
223	223
224		~~Normal~~Param Param :=
	224	Param Param :=
225	225	a1:ParamFldMods? a2:PlainParam
226	226	{ if (a1 != null) {
…	…
238	238
239	239	/* ParamWType ::= BindId w IsType */
240		private ~~Normal~~Param PlainParamWType =
	240	private Param PlainParamWType =
241	241	a1:BindId w a2:IsType
242	242	{ yyValue = NodeFactory.makeParam(a1, a2); };

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

r3102	r3107
275	275	hasSelf = true;
276	276	if ( (! hasBody) &&
277		p ~~instanceof NormalParam~~ &&
278		~~((NormalParam)p)~~.getType().isNone() &&
	277	p.getVarargsType().isNone() &&
	278	p.getType().isNone() &&
279	279	! p.getName().getText().equals("self") )
280	280	log(p, "The type of " + p.getName() + " is required.");

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/phases/Transform.java

r3105	r3107
126	126
127	127	/* Support renaming for these nodes
128		* LValue ( only for LocalVarDecl ) - done
129		* FnDecl ( only for local function decls ) - done
130		* NormalParam ( only for FnExpr and local function decls ) - done
131		* VarargsParam ( only for FnExpr and local function decls ) - done
	128	* LValue ( only for LocalVarDecl ) - done
	129	* FnDecl ( only for local function decls ) - done
	130	* Param ( only for FnExpr and local function decls ) - done
132	131	* Label - done
133	132	* Typecase - done
…	…
306	305	final Transform transformer = Transform.this;
307	306	return (Param) value.accept( new TemplateUpdateVisitor(){
308		public Node forNormalParamOnly(NormalParam that, List<Modifier> mods_result, Id name_result, Option<Type> type_result, Option<Expr> defaultExpr_result) {
309		Debug.debug( Debug.Type.SYNTAX, 2, "Normal param id hash code " + name_result.generateHashCode() );
310		Id generatedId = renameId(name_result);
311		/*
312		Id old = (Id) name_result.accept(transformer);
313		Id generatedId = generateId(old);
314		Debug.debug( Debug.Type.SYNTAX, 2, "Generate new binding for " + old + " = " + generatedId );
315		extendSyntaxEnvironment(old, generatedId);
316		*/
317		return new NormalParam(that.getSpan(), mods_result, generatedId, type_result, defaultExpr_result);
318		}
319		public Node forVarargsParamOnly(VarargsParam that, List<Modifier> mods_result, Id name_result, Option<Type> type_result) {
320		Debug.debug( Debug.Type.SYNTAX, 2, "Varargs param id hash code " + name_result.generateHashCode() );
321		Id old = (Id) name_result.accept(transformer);
322		Id generatedId = generateId(old);
323		Debug.debug( Debug.Type.SYNTAX, 2, "Generate new binding for " + old + " = " + generatedId );
324		extendSyntaxEnvironment(old, generatedId);
325		return new VarargsParam(that.getSpan(), mods_result, generatedId, type_result);
	307	public Node forParamOnly(Param that, List<Modifier> mods_result,
	308	Id name_result, Option<Type> type_result,
	309	Option<Expr> defaultExpr_result,
	310	Option<Type> varargsType_result) {
	311	if ( varargsType_result.isNone() ) {
	312	Debug.debug( Debug.Type.SYNTAX, 2, "Normal param id hash code " + name_result.generateHashCode() );
	313	Id generatedId = renameId(name_result);
	314	/*
	315	Id old = (Id) name_result.accept(transformer);
	316	Id generatedId = generateId(old);
	317	Debug.debug( Debug.Type.SYNTAX, 2, "Generate new binding for " + old + " = " + generatedId );
	318	extendSyntaxEnvironment(old, generatedId);
	319	*/
	320	return new Param(that.getSpan(), mods_result, generatedId, type_result, defaultExpr_result);
	321	} else {
	322	Debug.debug( Debug.Type.SYNTAX, 2, "Varargs param id hash code " + name_result.generateHashCode() );
	323	Id old = (Id) name_result.accept(transformer);
	324	Id generatedId = generateId(old);
	325	Debug.debug( Debug.Type.SYNTAX, 2, "Generate new binding for " + old + " = " + generatedId );
	326	extendSyntaxEnvironment(old, generatedId);
	327	return new Param(that.getSpan(), mods_result, generatedId, Option.<Type>none(), Option.<Expr>none(),
	328	varargsType_result);
	329	}
326	330	}
327	331	});

trunk/ProjectFortress/src/com/sun/fortress/tools/FortressAstToConcrete.java

r3105	r3107
682	682	}
683	683
684		@Override public String forNormalParamOnly(NormalParam that,
685		List<String> mods_result,
686		String name_result,
687		Option<String> type_result,
688		Option<String> defaultExpr_result) {
	684	@Override public String forParamOnly(Param that,
	685	List<String> mods_result,
	686	String name_result,
	687	Option<String> type_result,
	688	Option<String> defaultExpr_result,
	689	Option<String> varargsType_result) {
689	690	StringBuilder s = new StringBuilder();
690	691
…	…
693	694	}
694	695	s.append( name_result );
695		if (type_result.isSome() &&
696		!name_result.equals("self"))
697		s.append( handleType(type_result.unwrap()) );
698		if (defaultExpr_result.isSome())
699		s.append( "=").append( defaultExpr_result );
700
701		return s.toString();
702		}
703
704		@Override public String forVarargsParamOnly(VarargsParam that,
705		List<String> mods_result,
706		String name_result,
707		Option<String> type_result) {
708		StringBuilder s = new StringBuilder();
709
710		for ( String mod : mods_result ){
711		s.append( mod ).append( " " );
712		}
713		s.append( name_result );
714		s.append( handleType(type_result.unwrap()) );
715		s.append( "..." );
	696
	697	if ( varargsType_result.isNone() ) {
	698	if (type_result.isSome() &&
	699	!name_result.equals("self"))
	700	s.append( handleType(type_result.unwrap()) );
	701	if (defaultExpr_result.isSome())
	702	s.append( "=").append( defaultExpr_result );
	703	} else {
	704	s.append( handleType(varargsType_result.unwrap()) );
	705	s.append( "..." );
	706	}
716	707
717	708	return s.toString();

Context Navigation

Changeset 3107

Legend:

Download in other formats: