added todos and a make(Production) function to mirror getConstructor …

…and added missing cases to \data modifier in Type

and regenerated the Rascal parser with Arnold's bugfixes

src/org/rascalmpl/library/ParseTree.rsc

@@ -297,6 +297,14 @@ Symbol \data(\lexical(Symbol s)) = \data(s);
 Symbol \data(\keyword(Symbol s)) = \data(s);
 Symbol \data(\layout(Symbol s))  = \data(s);
 
+Symbol \data(a:adt(n, ps))               = a;
+Symbol \data(sort(n))                    = \adt(n, []);
+Symbol \data(\parameterized-sort(n, ps)) = \adt(n, ps);
+Symbol \data(lex(n))                     = \adt(n, []);
+Symbol \data(\parameterized-lex(n, ps))  = \adt(n, ps);
+Symbol \data(\keywords(n))               = \adt(n, []);
+Symbol \data(\layouts(n))                = \adt(n, []);
+
 Symbol \syntax(\data(Symbol s))    = \syntax(s);
 Symbol \syntax(\syntax(Symbol s))  = \syntax(s);
 Symbol \syntax(\lexical(Symbol s)) = \syntax(s);
@@ -776,7 +784,6 @@ data Exp = add(Exp, Exp);
 }
 java &T<:value implode(type[&T<:value] t, Tree tree);
 
-
 @synopsis{Annotate a parse tree node with an (error) message.}
 anno Message Tree@message;
 

src/org/rascalmpl/library/Type.java

@@ -120,5 +120,45 @@ public IValue make(IValue type, IString name, IList args, IMap keywordParameters
 			throw RuntimeExceptionFactory.illegalArgument(type, null, null);
 		}
 	}
+
+	public IValue make(IConstructor cons, IList args, IMap keywordParameters) {
+		io.usethesource.vallang.type.Type constructor = new TypeReifier(vf).productionToConstructorType(cons);
+
+		assert constructor != null;
+
+		IValue[] children = new IValue[args.length()];
+		io.usethesource.vallang.type.Type[] argsTypes = new io.usethesource.vallang.type.Type[args.length()];
+
+		for (int i = 0; i < args.length(); i++) {
+			children[i] = args.get(i);
+			argsTypes[i] = children[i].getType();
+		}
+
+		Map<String, IValue> kwmap;
+
+		if(keywordParameters.size() == 0){
+			kwmap = Collections.emptyMap();
+		} else {
+			Iterator<Entry<IValue, IValue>> iter = keywordParameters.entryIterator();
+			kwmap = new HashMap<String, IValue>();
+			while(iter.hasNext()){
+				Entry<IValue, IValue> entry = iter.next();
+				kwmap.put(((IString) entry.getKey()).getValue(), entry.getValue());
+			}
+		}
+
+		try {
+			if (constructor == null) {
+				// TODO: improve error messaging, using specialized exception
+				throw RuntimeExceptionFactory.illegalArgument(cons, null, null);
+			}
+			return vf.constructor(constructor, children, kwmap);
+
+		}
+		catch (FactTypeUseException e) {
+			// TODO: improve error messaging, using specialized exception
+			throw RuntimeExceptionFactory.illegalArgument(cons, null, null);
+		}
+	}
 
 }

src/org/rascalmpl/library/Type.rsc

@@ -507,7 +507,11 @@ public java &T make(type[&T] typ, str name, list[value] args);
 
 @javaClass{org.rascalmpl.library.Type}
 public java &T make(type[&T] typ, str name, list[value] args, map[str,value] keywordArgs);
-
+
+@javaClass{org.rascalmpl.library.Type}
+@synopsis{Instantiate a constructor value by first declaring the given constructor and then applying it to the given parameters}
+public java &T make(Production cons, list[value] args, map[str,value] keywordArgs);
+
 @synopsis{Returns the dynamic type of a value as a ((Type-Symbol)).}
 @description{
 As opposed to the # operator, which produces the type of a value statically, this

src/org/rascalmpl/library/lang/rascal/syntax/Rascal.rsc

@@ -734,7 +734,7 @@ syntax Type
 	| modifier: SyntaxRoleModifier modifier
 	;
 
-syntax SyntaxRoleModifier
+syntax SyntaxRoleModifier // TODO @rodin zegt dat dit Type moet zijn en niet TypeArg
 	= \syntax: "syntax" "[" TypeArg arg "]"
 	| \lexical: "lexical" "[" TypeArg arg "]"
 	| \layout: "layout" "[" TypeArg arg "]"