fixed PR review by @rodinaarssen

Author: rodinaarssen

src/org/rascalmpl/compiler/lang/rascalcore/check/AType.rsc

@@ -246,9 +246,12 @@ bool asubtype(\asyntaxRoleModifier(SyntaxRole role, \aparameter(_,_)), aadt(_, _
 // All open syntax role modifiers are sub-types of `node`
 bool asubtype(\asyntaxRoleModifier(SyntaxRole role, \aparameter(_,_)), anode(_)) = true;
 
+@synopsis{These are the roles for values of the Tree type}
+private set[SyntaxRole] treeSyntaxRoles = {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+
 // All context-free grammar-related syntax roles are sub-types of `Tree`
 bool asubtype(\asyntaxRoleModifier(SyntaxRole role, \aparameter(_,_)), aadt("Tree", [], dataSyntax())) = true
-    when role in {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+    when role in treeSyntaxRoles;
 
 bool asubtype(\start(AType a), AType b) = asubtype(a, b);
 
@@ -562,12 +565,6 @@ bool outerComparable1(aparameter(str pname1, AType bound1), aparameter(str pname
 
 bool outerComparable1(aadt(str adtName1, list[AType] parameters1, SyntaxRole syntaxRole1),  areified(_)) = true;
 
-// syntax role with incomparable roles are not outer comparable, but otherwise they act like aadt's:
-// JV: commented out until I understand the use of outerComparable1 better.
-// bool outerComparable1(asyntaxRoleModifier(SyntaxRole role, aparameter(_,_)), asyntaxRoleModifier(role, aparameter(_,_))) = true;
-// bool outerComparable1(asyntaxRoleModifier(SyntaxRole role, aparameter(_,_)), aadt(_,_,role)) = true;
-// bool outerComparable1(aadt(_,_,role), asyntaxRoleModifier(SyntaxRole role, aparameter(_,_))) = true;
-
 default bool outerComparable1(AType l, AType r) {
     return comparable(l, r);
 }
@@ -751,11 +748,11 @@ AType alub(\anode(l), \asyntaxRoleModifier(_, \aparameter(_, _))) = \anode(l);
 
 AType alub(\asyntaxRoleModifier(SyntaxRole role, \aparameter(_, _)), aadt("Tree",[], dataSyntax())) 
     = aadt("Tree",[], dataSyntax())
-    when role in {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+    when role in treeSyntaxRoles;
 
 AType alub(aadt("Tree",[], dataSyntax()), \asyntaxRoleModifier(SyntaxRole role, \aparameter(_, _))) 
     = aadt("Tree",[], dataSyntax())
-    when role in {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+    when role in treeSyntaxRoles;
 
 // ---
 
@@ -767,7 +764,7 @@ AType alub(\asyntaxRoleModifier(SyntaxRole _, \aparameter(x, _)),
 
 AType alub(\asyntaxRoleModifier(SyntaxRole a, \aparameter(x, _)),
            \asyntaxRoleModifier(SyntaxRole b, \aparameter(y, _))) = aadt("Tree",[], dataSyntax()) 
-    when x != y, {a,b} < {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+    when {a,b} < treeSyntaxRoles;
 
 AType alub(l:\achar-class(_), r:\achar-class(_)) = union(l, r);
 
@@ -945,10 +942,10 @@ AType aglb(a:asyntaxRoleModifier(SyntaxRole _, aparameter(_,_)), \anode(_)) = a;
 AType aglb(\anode(_), a:asyntaxRoleModifier(SyntaxRole _, aparameter(_,_))) = a;
 
 AType aglb(a:asyntaxRoleModifier(SyntaxRole role, aparameter(_,_)), aadt("Tree", [], dataSyntax())) = a
-    when role in {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+    when role in treeSyntaxRoles;
 
 AType aglb(aadt("Tree", [], dataSyntax()), a:asyntaxRoleModifier(SyntaxRole role, aparameter(_,_))) = a
-    when role in {contextFreeSyntax(), lexicalSyntax(), keywordSyntax(), layoutSyntax()};
+    when role in treeSyntaxRoles;
 
 public list[AType] aglbList(list[AType] l, list[AType] r) = [aglb(l[idx],r[idx]) | idx <- index(l)] when size(l) == size(r);
 public default list[AType] aglbList(list[AType] l, list[AType] r) = [avalue()];

src/org/rascalmpl/library/Type.java

@@ -36,7 +36,7 @@
 public class Type {
 	private final IRascalValueFactory vf;
 
-	public Type(IRascalValueFactory vf, TypeFactory tf) {
+	public Type(IRascalValueFactory vf) {
 		this.vf = vf;
 	}
 

src/org/rascalmpl/library/lang/paths/Windows.rsc

@@ -10,7 +10,7 @@ The main function of this module, ((parseWindowsPath)):
 * throws a ParseError if the path does not comply. Typically file names ending in spaces do not comply.
 * ensures that if the file exists on system A, then the `loc` representation
 resolves to the same file on system A via any ((Library:module:IO)) function. 
-* and nothing more. No normalization, no interpretation of `.` and `..`, no changing of cases. 
+* and nothing more. No normalization, no interpretation of `.` and `..`, no changing of cases.
 This is left to downstream processors of `loc` values, if necessary. The current transformation
 is purely syntactical, and tries to preserve the semantics of the path as much as possible.
 }