Syntax changes for tuples and sequences; symbols.

11 files changed, 115 insertions, 120 deletions

diff --git a/sources/scalac/ast/LazyTreeFactory.java b/sources/scalac/ast/LazyTreeFactory.java
index 43cef5652a..26f5f9a98f 100644
--- a/sources/scalac/ast/LazyTreeFactory.java
+++ b/sources/scalac/ast/LazyTreeFactory.java
@@ -397,16 +397,6 @@ public class LazyTreeFactory extends AbstractTreeCopyFactory {
         return tree;
     }
 
-    public Tree TupleType(Tree tree,
-                          Tree[] types) {
-        TupleType t = (TupleType)tree;
-        if (t.types == types)
-            return t;
-        tree = make.TupleType(t.pos, types);
-        attribute(tree, t);
-        return tree;
-    }
-
     public Tree AppliedType(Tree tree,
                             Tree tpe,
                             Tree[] args) {
diff --git a/sources/scalac/ast/Transformer.java b/sources/scalac/ast/Transformer.java
index 1789801c7e..5425f2ebf3 100644
--- a/sources/scalac/ast/Transformer.java
+++ b/sources/scalac/ast/Transformer.java
@@ -312,9 +312,6 @@ public class Transformer extends Phase {
 	    return copy.CompoundType(tree,
 				     transform(parents),
 				     transform(refinements));
-	case TupleType(Tree[] types):
-	    return copy.TupleType(tree,
-				  transform(types));
 	case AppliedType(Tree tpe, Tree[] args):
 	    return copy.AppliedType(tree,
 				    transform(tpe),
@@ -389,8 +386,6 @@ public class Transformer extends Phase {
 
 	case CompoundType(Tree[] baseTypes, Tree[] refinements):
 
-	case TupleType(Tree[] types):
-
 	case AppliedType(Tree tpe, Tree[] args):
 
 	default:
diff --git a/sources/scalac/ast/Traverser.java b/sources/scalac/ast/Traverser.java
index 5c39d9e315..ad40be1f06 100644
--- a/sources/scalac/ast/Traverser.java
+++ b/sources/scalac/ast/Traverser.java
@@ -185,10 +185,6 @@ public class Traverser {
             traverse(refinements);
             return;
 
-        case TupleType(Tree[] types):
-            traverse(types);
-            return;
-
         case AppliedType(Tree tpe, Tree[] args):
             traverse(tpe);
             traverse(args);
diff --git a/sources/scalac/ast/Tree.java b/sources/scalac/ast/Tree.java
index 80304ea78e..6ee74544e1 100644
--- a/sources/scalac/ast/Tree.java
+++ b/sources/scalac/ast/Tree.java
@@ -309,17 +309,6 @@ public class Tree {
 	}
     }
 
-/** tuple type (~ Tuple)
- */
-    public case TupleType(Tree[] types) {
-	if (types != null) {
-	    for (int i = 0; i < types.length; i++) {
-		if (!types[i].isType())
-		    throw new ApplicationError("TupleType requires types.");
-	    }
-	}
-    }
-
     /** applied type
      */
     public case AppliedType(Tree tpe, Tree[] args) {
@@ -755,7 +744,6 @@ public class Tree {
 	case SelectFromType(_, _):
 	case CompoundType(_, _):
 	case FunType(_, _):
-	case TupleType(_):
 	case AppliedType(_, _):
 	case CovariantType(_):
 	    return true;
diff --git a/sources/scalac/ast/TreeCopyFactory.java b/sources/scalac/ast/TreeCopyFactory.java
index 5a9074c39f..76294fd583 100644
--- a/sources/scalac/ast/TreeCopyFactory.java
+++ b/sources/scalac/ast/TreeCopyFactory.java
@@ -152,9 +152,6 @@ public interface TreeCopyFactory {
                              Tree[] baseTypes,
                              Tree[] refinements);
 
-    public Tree TupleType(Tree tree,
-                          Tree[] types);
-
     public Tree AppliedType(Tree tree,
                             Tree tpe,
                             Tree[] args);
diff --git a/sources/scalac/ast/TreeCreator.java b/sources/scalac/ast/TreeCreator.java
index 6cb8afa1d8..e9bb124465 100644
--- a/sources/scalac/ast/TreeCreator.java
+++ b/sources/scalac/ast/TreeCreator.java
@@ -269,13 +269,6 @@ public class TreeCreator implements TreeFactory {
         return t;
     }
 
-    public Tree TupleType(int pos,
-                          Tree[] types) {
-        Tree t = new TupleType(types);
-        t.pos = pos;
-        return t;
-    }
-
     public Tree AppliedType(int pos,
                             Tree tpe,
                             Tree[] args) {
diff --git a/sources/scalac/ast/TreeFactory.java b/sources/scalac/ast/TreeFactory.java
index 31ee67042e..a5d6b914bc 100644
--- a/sources/scalac/ast/TreeFactory.java
+++ b/sources/scalac/ast/TreeFactory.java
@@ -143,9 +143,6 @@ public interface TreeFactory {
                              Tree[] baseTypes,
                              Tree[] refinements);
 
-    public Tree TupleType(int pos,
-                          Tree[] types);
-
     public Tree AppliedType(int pos,
                             Tree tpe,
                             Tree[] args);
diff --git a/sources/scalac/ast/parser/Parser.java b/sources/scalac/ast/parser/Parser.java
index cd491e2af9..f9aa54cb3a 100644
--- a/sources/scalac/ast/parser/Parser.java
+++ b/sources/scalac/ast/parser/Parser.java
@@ -141,10 +141,11 @@ public class Parser implements Tokens {
     boolean isExprIntro() {
 	switch (s.token) {
 	case CHARLIT: case INTLIT: case LONGLIT:
-	case FLOATLIT: case DOUBLELIT: case STRINGLIT: case NULL:
-	case IDENTIFIER: case THIS: case SUPER:
-	case IF: case FOR: case NEW: case USCORE:
-	case LPAREN: case LBRACKET: case LBRACE:
+	case FLOATLIT: case DOUBLELIT: case STRINGLIT:
+	case SYMBOLLIT: case NULL: case IDENTIFIER:
+	case THIS: case SUPER: case IF:
+	case FOR: case NEW: case USCORE:
+	case LPAREN: case LBRACE:
 	    return true;
 	default:
 	    return false;
@@ -191,12 +192,44 @@ public class Parser implements Tokens {
 	return make.Select(pos, make.Ident(pos, Names.scala), Names.Any.toTypeName());
     }
 
+    /** Create tree representing type scala.Seq
+     */
+    Tree scalaSeqType(int pos) {
+	return make.Select(pos, make.Ident(pos, Names.scala), Names.Seq.toTypeName());
+    }
+
     /** Create tree representing constructor scala.Object
      */
     Tree scalaObjectConstr(int pos) {
 	return make.Select(pos, make.Ident(pos, Names.scala), Names.Object.toConstrName());
     }
 
+    /** Create tree representing method scala.Symbol
+     */
+    Tree scalaSymbol(int pos) {
+	return make.Select(pos, make.Ident(pos, Names.scala), Names.Symbol);
+    }
+
+    /** Create tree representing method scala.Labelled
+     */
+    Tree scalaLabelled(int pos) {
+	return make.Select(pos, make.Ident(pos, Names.scala), Names.Labelled);
+    }
+
+    /** Create tree representing method scala.Predef.List
+     */
+    Tree scalaPredefList(int pos) {
+	return make.Select(pos,
+	    make.Select(pos, make.Ident(pos, Names.scala), Names.Predef),
+	    Names.List);
+    }
+
+    /** Create tree representing type scala.List
+     */
+    Tree scalaListType(int pos) {
+	return make.Select(pos, make.Ident(pos, Names.scala), Names.List.toTypeName());
+    }
+
     /** Create tree for for-comprehension <for (enums) do body> or
      *   <for (enums) yield body> where mapName and flatmapName are chosen
      *  corresponding to whether this is a for-do or a for-yield.
@@ -364,6 +397,7 @@ public class Parser implements Tokens {
     static final Name PLUS = Name.fromString("+");
     static final Name BANG = Name.fromString("!");
     static final Name TILDE = Name.fromString("~");
+    static final Name STAR = Name.fromString("*");
 
     Name ident() {
         if (s.token == IDENTIFIER) {
@@ -431,9 +465,10 @@ public class Parser implements Tokens {
     }
 
     /** SimpleExpr    ::= literal
+     *                  | symbol [ArgumentExprs]
      *                  | null
      */
-    Tree literal() {
+    Tree literal(boolean isPattern) {
 	Tree t;
 	switch (s.token) {
 	case CHARLIT:
@@ -457,6 +492,23 @@ public class Parser implements Tokens {
 	case NULL:
 	    t = make.Ident(s.pos, Names.null_);
 	    break;
+	case SYMBOLLIT:
+	    Tree symt = scalaSymbol(s.pos);
+	    if (isPattern) symt = convertToTypeId(symt);
+	    t = make.Apply(s.pos,
+		symt,
+		new Tree[]{make.Literal(s.pos, s.name.toString())});
+	    s.nextToken();
+	    if (s.token == LPAREN || s.token == LBRACE) {
+		Tree labt = scalaLabelled(s.pos);
+		if (isPattern) labt = convertToTypeId(labt);
+		Tree listt = isPattern ? scalaListType(s.pos)
+		    : scalaPredefList(s.pos);
+		t = make.Apply(s.pos,
+		    labt,
+		    new Tree[]{t, make.Apply(s.pos, listt, argumentExprs())});
+	    }
+	    return t;
 	default:
 	    return syntaxError("illegal literal", true);
 	}
@@ -549,7 +601,6 @@ public class Parser implements Tokens {
      *               | SimpleType `#' Id
      *               | StableId
      *               | StableRef `.' type
-     *               | `[' Types `]'
      *               | `(' Type `)'
      */
     Tree simpleType() {
@@ -559,11 +610,6 @@ public class Parser implements Tokens {
 	    s.nextToken();
 	    t = type();
 	    accept(RPAREN);
-	} else if (s.token == LBRACKET) {
-	    s.nextToken();
-	    Tree[] ts = types();
-	    accept(RBRACKET);
-	    t = make.TupleType(pos, ts);
 	} else {
 	    t = convertToTypeId(stableRef(false, true));
 	}
@@ -744,7 +790,6 @@ public class Parser implements Tokens {
      *                 | super `.' Id
      *                 | SimpleExpr `.' Id
      *                 | `(' [Expr] `)'
-     *                 | `[' [Exprs] `]'
      *                 | BlockExpr
      *                 | SimpleExpr `@' TypeArgs
      *                 | SimpleExpr ArgumentExprs
@@ -760,8 +805,9 @@ public class Parser implements Tokens {
 	case FLOATLIT:
 	case DOUBLELIT:
 	case STRINGLIT:
+	case SYMBOLLIT:
 	case NULL:
-	    t = literal();
+	    t = literal(false);
 	    break;
 	case IDENTIFIER:
 	case THIS:
@@ -794,14 +840,6 @@ public class Parser implements Tokens {
 		}
 	    }
 	    break;
-	case LBRACKET:
-	    int pos = s.skipToken();
-	    Tree[] ts;
-	    if (s.token == RBRACKET) ts = Tree.EMPTY_ARRAY;
-	    else ts = exprs();
-	    t = make.Tuple(pos, ts);
-	    accept(RBRACKET);
-	    break;
 	case LBRACE:
 	    t = blockExpr();
 	    break;
@@ -816,12 +854,10 @@ public class Parser implements Tokens {
 	    case DOT:
 		t = make.Select(s.skipToken(), t, ident());
 		break;
-	    case AT:
-		int pos = s.skipToken();
-		t = make.TypeApply(pos, t, typeArgs());
+	    case LBRACKET:
+		t = make.TypeApply(s.pos, t, typeArgs());
 		break;
 	    case LPAREN:
-	    case LBRACKET:
 	    case LBRACE:
 		t = make.Apply(s.pos, t, argumentExprs());
 		break;
@@ -832,19 +868,12 @@ public class Parser implements Tokens {
     }
 
     /** ArgumentExprs ::= `(' [Exprs] `)'
-     *                  | `[' [Exprs] `]'
      *                  | BlockExpr
      */
     Tree[] argumentExprs() {
 	Tree[] ts = Tree.EMPTY_ARRAY;
 	if (s.token == LBRACE) {
 	    ts = new Tree[]{blockExpr()};
-	} else if (s.token == LBRACKET) {
-	    int pos = s.skipToken();
-	    if (s.token != RBRACKET)
-		ts = exprs();
-	    accept(RBRACKET);
-	    ts = new Tree[]{make.Tuple(pos, ts)};
 	} else {
 	    accept(LPAREN);
 	    if (s.token != RPAREN)
@@ -982,15 +1011,14 @@ public class Parser implements Tokens {
      *                 | null
      *                 | StableId {ArgumentPatterns}
      *                 | `(' Pattern `)'
-     *                 | `[' [Patterns] `]'
      */
     Tree simplePattern() {
 	switch (s.token) {
 	case IDENTIFIER:
 	case THIS:
 	    Tree t = stableId();
-	    while (s.token == LPAREN || s.token == LBRACKET) {
-		t = make.Apply(s.pos, convertToConstr(t), argumentPatterns());
+	    while (s.token == LPAREN) {
+		t = make.Apply(s.pos, convertToTypeId(t), argumentPatterns());
 	    }
 	    return t;
 	case USCORE:
@@ -1001,45 +1029,28 @@ public class Parser implements Tokens {
 	case FLOATLIT:
 	case DOUBLELIT:
 	case STRINGLIT:
+	case SYMBOLLIT:
 	case NULL:
-	    return literal();
+	    return literal(true);
 	case LPAREN:
 	    s.nextToken();
 	    Tree t = pattern();
 	    accept(RPAREN);
 	    return t;
-	case LBRACKET:
-	    return tuplePattern();
 	default:
 	    return syntaxError("illegal start of pattern", true);
 	}
     }
 
-    /** SimplePattern ::= `[' [Patterns] ']'
-     */
-    Tree tuplePattern() {
-	int pos = accept(LBRACKET);
-	Tree[] ts;
-	if (s.token == RBRACKET) ts = Tree.EMPTY_ARRAY;
-	else ts = patterns();
-	accept(RBRACKET);
-	return make.Tuple(pos, ts);
-    }
-
-    /** ArgumentPatterns ::= `(' [Patterns] `)'
-     *                     | `[' [Patterns] `]'
+    /** ArgumentPatterns ::= `[' [Patterns] `]'
      */
     Tree[] argumentPatterns() {
-	if (s.token == LBRACKET) {
-	    return new Tree[]{tuplePattern()};
-	} else {
-	    Tree[] ts = Tree.EMPTY_ARRAY;
-	    accept(LPAREN);
-	    if (s.token != RPAREN)
-		ts = patterns();
-	    accept(RPAREN);
-	    return ts;
-	}
+	Tree[] ts = Tree.EMPTY_ARRAY;
+	accept(LPAREN);
+	if (s.token != RPAREN)
+	    ts = patterns();
+	accept(RPAREN);
+	return ts;
     }
 
 ////////// MODIFIERS ////////////////////////////////////////////////////////////
@@ -1133,7 +1144,7 @@ public class Parser implements Tokens {
         return (ValDef[])params.copyTo(new ValDef[params.length()]);
     }
 
-    /** Param ::= [def] Id `:' Type
+    /** Param ::= [def] Id `:' Type [`*']
      */
     ValDef param() {
         int pos = s.pos;
@@ -1144,7 +1155,13 @@ public class Parser implements Tokens {
         }
 	Name name = ident();
 	accept(COLON);
-        return (ValDef)make.ValDef(pos, mods, name, type(), Tree.Empty);
+	Tree tp = type();
+	if (s.token == IDENTIFIER && s.name == STAR) {
+	    s.nextToken();
+	    mods |= Modifiers.REPEATED;
+	    tp = make.AppliedType(tp.pos, scalaSeqType(tp.pos), new Tree[]{tp});
+	}
+        return (ValDef)make.ValDef(pos, mods, name, tp, Tree.Empty);
     }
 
     /** TypeParamClauseOpt ::= [`[' TypeSig {`,' TypeSig} `]']
diff --git a/sources/scalac/ast/parser/Scanner.java b/sources/scalac/ast/parser/Scanner.java
index 0e4af3a09d..a86014d650 100644
--- a/sources/scalac/ast/parser/Scanner.java
+++ b/sources/scalac/ast/parser/Scanner.java
@@ -113,7 +113,7 @@ public class Scanner extends TokenData {
 	    case YIELD:  case DO:
 	    case COMMA:  case SEMI:     case DOT:
 	    case COLON:  case EQUALS:   case ARROW:
-            case LARROW: case SUBTYPE:  case AT:
+            case LARROW: case SUBTYPE:
             case HASH:   case AS:       case IS:
 	    case RPAREN: case RBRACKET: case RBRACE:
 		break;
@@ -249,7 +249,31 @@ public class Scanner extends TokenData {
 		case '\'':
 		    nextch();
 		    litlen = 0;
-		    getlitch();
+		    switch (ch) {
+		    case 'A': case 'B': case 'C': case 'D': case 'E':
+		    case 'F': case 'G': case 'H': case 'I': case 'J':
+		    case 'K': case 'L': case 'M': case 'N': case 'O':
+		    case 'P': case 'Q': case 'R': case 'S': case 'T':
+		    case 'U': case 'V': case 'W': case 'X': case 'Y':
+		    case 'Z': case '$':
+		    case 'a': case 'b': case 'c': case 'd': case 'e':
+		    case 'f': case 'g': case 'h': case 'i': case 'j':
+		    case 'k': case 'l': case 'm': case 'n': case 'o':
+		    case 'p': case 'q': case 'r': case 's': case 't':
+		    case 'u': case 'v': case 'w': case 'x': case 'y':
+		    case 'z':
+			index = bp;
+			putch(ch);
+			nextch();
+			if (ch != '\'') {
+			    getIdentRest(index);
+			    token = SYMBOLLIT;
+			    return;
+			}
+			break;
+		    default:
+			getlitch();
+		    }
 		    if (ch == '\'') {
 			nextch();
 			token = CHARLIT;
@@ -668,6 +692,8 @@ public class Scanner extends TokenData {
                 return "double literal";
             case STRINGLIT:
                 return "string literal";
+            case SYMBOLLIT:
+                return "symbol literal";
             case LPAREN:
                 return "'('";
             case RPAREN:
@@ -688,11 +714,15 @@ public class Scanner extends TokenData {
                 return "';'";
             case COMMA:
                 return "','";
+	    case CASECLASS:
+		return "case class";
             default:
                 try {
                     return "'" + tokenName[token].toString() + "'";
                 } catch (ArrayIndexOutOfBoundsException e) {
                     return "'<" + token + ">'";
+                } catch (NullPointerException e) {
+                    return "'<(" + token + ")>'";
                 }
         }
     }
@@ -782,7 +812,6 @@ public class Scanner extends TokenData {
         enterKeyword("<:", SUBTYPE);
         enterKeyword("yield", YIELD);
         enterKeyword("do", DO);
-        enterKeyword("@", AT);
         enterKeyword("#", HASH);
         enterKeyword("trait", TRAIT);
 	enterKeyword("as", AS);
diff --git a/sources/scalac/ast/parser/Tokens.java b/sources/scalac/ast/parser/Tokens.java
index 6c3bef6a55..2fa82eb5f3 100644
--- a/sources/scalac/ast/parser/Tokens.java
+++ b/sources/scalac/ast/parser/Tokens.java
@@ -21,6 +21,7 @@ public interface Tokens {
         FLOATLIT = 4,
         DOUBLELIT = 5,
         STRINGLIT = 6,
+        SYMBOLLIT = 7,
 
         /* identifier */
         IDENTIFIER = 10,
@@ -66,11 +67,10 @@ public interface Tokens {
         USCORE = 64,
         COLON = 65,
         EQUALS = 66,
-        LARROW = 57,
+        LARROW = 67,
         ARROW = 68,
         SUBTYPE = 69,
-        AT = 70,
-        HASH = 71,
+        HASH = 70,
 
         /* parenthesis */
         LPAREN = 90,
diff --git a/sources/scalac/ast/printer/TextTreePrinter.java b/sources/scalac/ast/printer/TextTreePrinter.java
index 6cb7ac368c..58010b8412 100644
--- a/sources/scalac/ast/printer/TextTreePrinter.java
+++ b/sources/scalac/ast/printer/TextTreePrinter.java
@@ -170,7 +170,6 @@ public class TextTreePrinter implements TreePrinter {
     protected static final Text TXT_COMMA         = Text.Simple(",");
     protected static final Text TXT_EQUAL         = Text.Simple("=");
     protected static final Text TXT_SUBTYPE       = Text.Simple("<:");
-    protected static final Text TXT_AT            = Text.Simple("@");
     protected static final Text TXT_HASH          = Text.Simple("#");
     protected static final Text TXT_RIGHT_ARROW   = Text.Simple("=>");
     protected static final Text TXT_LEFT_PAREN    = Text.Simple("(");
@@ -251,7 +250,6 @@ public class TextTreePrinter implements TreePrinter {
             print(KW_PACKAGE);
             print(Text.Space);
             print(packaged);
-            print(Text.Space);
             printTemplate(KW_WITH, impl, true);
             break;
 
@@ -412,7 +410,6 @@ public class TextTreePrinter implements TreePrinter {
 
         case TypeApply(Tree fun, Tree[] targs):
             print(fun);
-	    print(TXT_AT);
             printArray(targs, TXT_LEFT_BRACKET, TXT_RIGHT_BRACKET, TXT_COMMA_SP);
             printType(tree);
             break;
@@ -492,10 +489,6 @@ public class TextTreePrinter implements TreePrinter {
             printArray(refinements, TXT_WITH_BLOCK_BEGIN, TXT_BLOCK_END, Text.Newline);
             break;
 
-        case TupleType(Tree[] types):
-            printArray(types, TXT_LEFT_BRACKET, TXT_RIGHT_BRACKET, TXT_COMMA_SP);
-            break;
-
         case AppliedType(Tree tpe, Tree[] args):
             print(tpe);
 	    indent();