From e5b3a8a6b49dd4ab333781e3e7ce595ba14b06eb Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 13 Feb 2007 22:06:58 +0000 Subject: changed tuple syntax to (...) --- src/actors/scala/actors/Actor.scala | 2 +- src/compiler/scala/tools/ant/Scalac.scala | 2 +- src/compiler/scala/tools/nsc/Global.scala | 4 +- src/compiler/scala/tools/nsc/Interpreter.scala | 2 +- src/compiler/scala/tools/nsc/ast/TreeGen.scala | 5 +- .../scala/tools/nsc/ast/TreePrinters.scala | 2 +- src/compiler/scala/tools/nsc/ast/Trees.scala | 10 +- .../scala/tools/nsc/ast/parser/MarkupParsers.scala | 2 +- .../scala/tools/nsc/ast/parser/Parsers.scala | 313 +++++++-------------- .../scala/tools/nsc/ast/parser/TreeBuilder.scala | 48 ++-- .../scala/tools/nsc/backend/icode/GenICode.scala | 30 +- .../scala/tools/nsc/backend/icode/Members.scala | 2 +- .../scala/tools/nsc/backend/jvm/GenJVM.scala | 78 ++--- .../scala/tools/nsc/backend/msil/GenMSIL.scala | 24 +- .../scala/tools/nsc/matching/PatternMatchers.scala | 4 +- .../scala/tools/nsc/matching/PatternNodes.scala | 8 +- .../scala/tools/nsc/symtab/SymbolLoaders.scala | 4 +- src/compiler/scala/tools/nsc/symtab/Symbols.scala | 2 +- src/compiler/scala/tools/nsc/symtab/Types.scala | 152 +++++----- .../nsc/symtab/classfile/ClassfileParser.scala | 6 +- .../scala/tools/nsc/symtab/classfile/Pickler.scala | 12 +- .../tools/nsc/symtab/classfile/UnPickler.scala | 4 +- .../tools/nsc/typechecker/ConstantFolder.scala | 24 +- .../scala/tools/nsc/typechecker/Contexts.scala | 10 +- .../scala/tools/nsc/typechecker/Infer.scala | 48 ++-- .../scala/tools/nsc/typechecker/Namers.scala | 14 +- .../scala/tools/nsc/typechecker/RefChecks.scala | 10 +- .../tools/nsc/typechecker/SuperAccessors.scala | 4 +- .../tools/nsc/typechecker/SyntheticMethods.scala | 2 +- .../scala/tools/nsc/typechecker/Typers.scala | 68 ++--- src/library/scala/BigInt.scala | 4 +- src/library/scala/Console.scala | 6 +- src/library/scala/Iterator.scala | 12 +- src/library/scala/List.scala | 42 +-- src/library/scala/Stream.scala | 6 +- src/library/scala/collection/Map.scala | 4 +- src/library/scala/collection/MapProxy.scala | 2 +- .../scala/collection/immutable/EmptyMap.scala | 4 +- .../scala/collection/immutable/HashMap.scala | 4 +- .../scala/collection/immutable/ListMap.scala | 10 +- src/library/scala/collection/immutable/Map.scala | 24 +- src/library/scala/collection/immutable/Map1.scala | 4 +- src/library/scala/collection/immutable/Map2.scala | 4 +- src/library/scala/collection/immutable/Map3.scala | 4 +- src/library/scala/collection/immutable/Map4.scala | 2 +- src/library/scala/collection/immutable/Queue.scala | 12 +- .../scala/collection/immutable/RedBlack.scala | 8 +- src/library/scala/collection/immutable/Tree.scala | 48 ++-- .../scala/collection/immutable/TreeMap.scala | 4 +- .../collection/immutable/UnbalancedTreeMap.scala | 8 +- .../scala/collection/mutable/ArrayBuffer.scala | 2 +- src/library/scala/collection/mutable/Buffer.scala | 10 +- .../scala/collection/mutable/BufferProxy.scala | 2 +- .../scala/collection/mutable/DefaultMapModel.scala | 2 +- src/library/scala/collection/mutable/HashMap.scala | 2 +- src/library/scala/collection/mutable/History.scala | 10 +- .../collection/mutable/ImmutableMapAdaptor.scala | 4 +- .../scala/collection/mutable/JavaMapAdaptor.scala | 4 +- .../scala/collection/mutable/ListBuffer.scala | 2 +- src/library/scala/collection/mutable/Map.scala | 38 +-- .../scala/collection/mutable/MapProxy.scala | 20 +- .../collection/mutable/ObservableBuffer.scala | 12 +- .../scala/collection/mutable/ObservableMap.scala | 8 +- .../scala/collection/mutable/PriorityQueue.scala | 2 +- src/library/scala/collection/mutable/Queue.scala | 2 +- .../collection/mutable/RevertableHistory.scala | 2 +- src/library/scala/collection/mutable/Stack.scala | 2 +- .../collection/mutable/SynchronizedBuffer.scala | 2 +- .../scala/collection/mutable/SynchronizedMap.scala | 20 +- src/library/scala/concurrent/MailBox.scala | 22 +- src/library/scala/concurrent/Process.scala | 2 +- src/library/scala/concurrent/jolib.scala | 10 +- src/library/scala/concurrent/ops.scala | 4 +- src/library/scala/concurrent/pilib.scala | 14 +- src/library/scala/mobile/Code.scala | 18 +- src/library/scala/reflect/Type.scala | 2 +- src/library/scala/text/Document.scala | 44 +-- test/files/neg/patmatexhaust.scala | 8 +- test/files/run/patmatnew.scala | 12 +- test/files/run/tuples.scala | 6 +- 80 files changed, 649 insertions(+), 747 deletions(-) diff --git a/src/actors/scala/actors/Actor.scala b/src/actors/scala/actors/Actor.scala index 2e0d0185d5..458e41c9b4 100644 --- a/src/actors/scala/actors/Actor.scala +++ b/src/actors/scala/actors/Actor.scala @@ -627,7 +627,7 @@ trait Actor extends OutputChannel[Any] { // Assume !this.exiting private[actors] def exit(from: Actor, reason: AnyRef) { if (trapExit) { - this ! {'EXIT, from, reason} + this ! Triple('EXIT, from, reason) } else if (reason != 'normal) this.synchronized { diff --git a/src/compiler/scala/tools/ant/Scalac.scala b/src/compiler/scala/tools/ant/Scalac.scala index b16aacd2dd..7400cf610e 100644 --- a/src/compiler/scala/tools/ant/Scalac.scala +++ b/src/compiler/scala/tools/ant/Scalac.scala @@ -619,7 +619,7 @@ class Scalac extends MatchingTask { /** Performs the compilation. */ override def execute() = { - val {settings, sourceFiles} = initialize + val Pair(settings, sourceFiles) = initialize val reporter = new ConsoleReporter(settings) // Compiles the actual code diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 58f088002b..7636c39e9b 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -507,7 +507,7 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable showDef(newTermName(settings.Xshowobj.value), true) if (reporter.hasErrors) { - for (val {sym, file} <- symSource.elements) { + for (val Pair(sym, file) <- symSource.elements) { sym.reset(new loaders.SourcefileLoader(file)) if (sym.isTerm) sym.moduleClass.reset(loaders.moduleClassLoader) } @@ -520,7 +520,7 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable warning("there were unchecked warnings; re-run with -unchecked for details") } } - for (val {sym, file} <- symSource.elements) resetPackageClass(sym.owner) + for (val Pair(sym, file) <- symSource.elements) resetPackageClass(sym.owner) //units foreach (.clear()) informTime("total", startTime) } diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala index 119b68e5d3..6ea4d43143 100644 --- a/src/compiler/scala/tools/nsc/Interpreter.scala +++ b/src/compiler/scala/tools/nsc/Interpreter.scala @@ -102,7 +102,7 @@ class Interpreter(val settings: Settings, reporter: Reporter, out: PrintWriter) settings.outdir.value = classfilePath.getPath /** the compiler to compile expressions with */ - val compiler = new Global(settings, reporter) + val compiler: Global = new Global(settings, reporter) /** the compiler's classpath, as URL's */ val compilerClasspath: List[URL] = diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index 8be11e40b4..f639fc3c44 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -164,8 +164,9 @@ abstract class TreeGen { mkAttributedRef(definitions.NilModule) /** Builds a pair */ - def mkNewPair(left: Tree, right: Tree) = - New(Apply(mkAttributedRef(definitions.TupleClass(2)), List(left, right))) + def mkTuple(elems: List[Tree]): Tree = + if (elems.isEmpty) Literal(()) + else New(TypeTree(definitions.TupleClass(elems.length).tpe), List(elems)) def mkCached(cvar: Symbol, expr: Tree): Tree = { val cvarRef = if (cvar.owner.isClass) Select(This(cvar.owner), cvar) else Ident(cvar) diff --git a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala index 55b4bb0e2c..5d2afcc332 100644 --- a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala +++ b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala @@ -167,7 +167,7 @@ abstract class TreePrinters { print(symName(tree, name)); printRow(params, "(", ",", ")"); printBlock(rhs) case Import(expr, selectors) => - def selectorToString(s: {Name, Name}): String = + def selectorToString(s: Pair[Name, Name]): String = if (s._1 == nme.WILDCARD || s._1 == s._2) s._1.toString() else s._1.toString() + "=>" + s._2.toString() print("import "); print(expr) diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala index a7843c9fad..abcbcf3cf6 100644 --- a/src/compiler/scala/tools/nsc/ast/Trees.scala +++ b/src/compiler/scala/tools/nsc/ast/Trees.scala @@ -407,7 +407,7 @@ trait Trees requires Global { * @param expr * @param selectors */ - case class Import(expr: Tree, selectors: List[{Name, Name}]) + case class Import(expr: Tree, selectors: List[Pair[Name, Name]]) extends SymTree /** Annotation application (constructor arguments + name-value pairs) */ @@ -749,7 +749,7 @@ trait Trees requires Global { def AbsTypeDef(tree: Tree, mods: Modifiers, name: Name, lo: Tree, hi: Tree): AbsTypeDef def AliasTypeDef(tree: Tree, mods: Modifiers, name: Name, tparams: List[AbsTypeDef], rhs: Tree): AliasTypeDef def LabelDef(tree: Tree, name: Name, params: List[Ident], rhs: Tree): LabelDef - def Import(tree: Tree, expr: Tree, selectors: List[{Name, Name}]): Import + def Import(tree: Tree, expr: Tree, selectors: List[Pair[Name, Name]]): Import def Annotation(tree: Tree, constr: Tree, elements: List[Tree]): Annotation def DocDef(tree: Tree, comment: String, definition: Tree): DocDef def Template(tree: Tree, parents: List[Tree], body: List[Tree]): Template @@ -804,7 +804,7 @@ trait Trees requires Global { new AliasTypeDef(mods, name, tparams, rhs).copyAttrs(tree) def LabelDef(tree: Tree, name: Name, params: List[Ident], rhs: Tree) = new LabelDef(name, params, rhs).copyAttrs(tree) - def Import(tree: Tree, expr: Tree, selectors: List[{Name, Name}]) = + def Import(tree: Tree, expr: Tree, selectors: List[Pair[Name, Name]]) = new Import(expr, selectors).copyAttrs(tree) def Annotation(tree: Tree, constr: Tree, elements: List[Tree]) = new Annotation(constr, elements) @@ -921,7 +921,7 @@ trait Trees requires Global { if (name0 == name) && (params0 == params) && (rhs0 == rhs) => t case _ => copy.LabelDef(tree, name, params, rhs) } - def Import(tree: Tree, expr: Tree, selectors: List[{Name, Name}]) = tree match { + def Import(tree: Tree, expr: Tree, selectors: List[Pair[Name, Name]]) = tree match { case t @ Import(expr0, selectors0) if (expr0 == expr) && (selectors0 == selectors) => t case _ => copy.Import(tree, expr, selectors) @@ -1287,7 +1287,7 @@ trait Trees requires Global { traverse(expr) case Annotation(constr, elements) => traverse(constr); traverseTrees(elements) - case Annotated(constr: Tree, elements: List[Tree], arg: Tree) => + case Annotated(constr, elements, arg) => traverse(constr); traverseTrees(elements); traverse(arg) case DocDef(comment, definition) => traverse(definition) diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala index 4b85bd2b6d..4e1d73b53f 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala @@ -575,7 +575,7 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean */ def xScalaPatterns: List[Tree] = { sync; - val b = p.patterns(true, false); + val b = p.patterns(true); if (/*s.*/token != RBRACE) { reportSyntaxError(" expected end of Scala patterns"); } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index f85ffc8b4e..dfbc330145 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -256,16 +256,11 @@ trait Parsers requires SyntaxAnalyzer { /** Convert tree to formal parameter list */ - def convertToParams(t: Tree): List[ValDef] = t match { - case Function(params, TypeTree()) => - params - case Ident(_) | Typed(Ident(_), _) => - List(convertToParam(t)) - case Literal(c) if c.tag == UnitTag => - Nil + def convertToParams(tree: Tree): List[ValDef] = tree match { + case Parens(ts) => + ts map convertToParam case _ => - syntaxError(t.pos, "malformed formal parameter list", false) - Nil + List(convertToParam(tree)) } /** Convert tree to formal parameter @@ -278,7 +273,9 @@ trait Parsers requires SyntaxAnalyzer { case Typed(Ident(name), tpe) => ValDef(Modifiers(Flags.PARAM), name, tpe, EmptyTree) case _ => + Console.println("CTP "+tree) //debug syntaxError(tree.pos, "not a legal formal parameter", false) + throw new Error() ValDef(Modifiers(Flags.PARAM), nme.ERROR, errorTypeTree, EmptyTree) } } @@ -316,7 +313,7 @@ trait Parsers requires SyntaxAnalyzer { Function( List(ValDef(Modifiers(Flags.PARAM), pname, TypeTree(), EmptyTree)), - wrapLiftedGenerators(insertParam(tree))) + insertParam(tree)) } /////// OPERAND/OPERATOR STACK ///////////////////////////////////////////////// @@ -568,13 +565,15 @@ trait Parsers requires SyntaxAnalyzer { } else TypeTree() - /** Types ::= Type {`,' Type} - */ - def types(): List[Tree] = { - val ts = new ListBuffer[Tree] + typ() + /** Types ::= Type {`,' Type} [`,'] + * ArgTypePatterns ::= ArgTypePattern {`,' ArgTypePattern} [`,'] + */ + def types(isPattern: boolean): List[Tree] = { + val ts = new ListBuffer[Tree] + argType(isPattern) while (in.token == COMMA) { in.nextToken() - ts += typ() + if (in.token == RPAREN) return List(makeTupleType(ts.toList, false)) + ts += argType(isPattern) } ts.toList } @@ -584,14 +583,14 @@ trait Parsers requires SyntaxAnalyzer { final val LeftOp = 1 // left associative final val RightOp = 2 // right associative - /** Type ::= InfixType `=>' Type - * | `(' [Types | `=>' Type] `)' `=>' Type - * | InfixType + /** Type ::= InfixType [`=>' Type] + * | (`=>' Type) `=>' Type + * | `(' `)' `=>' Type */ def typ(): Tree = { val t = if (in.token == LPAREN) { - in.nextToken() + val pos = in.skipToken() if (in.token == RPAREN) { in.nextToken() atPos(accept(ARROW)) { makeFunctionTypeTree(List(), typ()) } @@ -601,24 +600,15 @@ trait Parsers requires SyntaxAnalyzer { accept(RPAREN) atPos(accept(ARROW)) { makeByNameFunctionTypeTree(t0, typ()) } } else { - val pos = in.currentPos - val t0 = typ() - if (in.token == COMMA) { - in.nextToken() - val ts = t0 :: types() - accept(RPAREN) - checkSize("function arguments", ts.length, definitions.MaxFunctionArity) - atPos (accept(ARROW)) { makeFunctionTypeTree(ts, typ()) } - } else { - accept(RPAREN) - infixTypeRest(pos, t0, false, FirstOp) - } + val ts = types(false) + accept(RPAREN) + if (in.token == ARROW) atPos(in.skipToken()) { makeFunctionTypeTree(ts, typ()) } + else infixTypeRest(pos, makeTupleType(ts, true), false, FirstOp) } } else { infixType(false, FirstOp) } - if (in.token == ARROW) atPos(in.skipToken()) { - makeFunctionTypeTree(List(t), typ()) } + if (in.token == ARROW) atPos(in.skipToken()) { makeFunctionTypeTree(List(t), typ()) } else t } @@ -667,35 +657,24 @@ trait Parsers requires SyntaxAnalyzer { * | SimpleType1 `#' Id * | StableId * | Path `.' type - * | `(' Type `)' - * | `{' [Type `,' [Types [`,']]] `}' - * SimpleTypePattern ::= SimpleTypePattern1 [TypePatternArgs] - * SimpleTypePattern1 ::= SimpleTypePattern1 "#" Id + * | `(' Types `)' + * SimpleTypePattern ::= Annotations SimpleTypePattern1 + * SimpleTypePattern1 ::= SimpleTypePattern2 [TypePatternArgs] + * SimpleTypePattern2 ::= SimpleTypePattern2 "#" Id * | StableId * | Path `.' type - * | `{' [ArgTypePattern `,' [ArgTypePatterns [`,']]] `}' + * | `(' ArgTypePattern {`,' ArgTypePattern} [`,'] `)' */ def simpleType(isPattern: boolean): Tree = { val annots = if (settings.Xplugtypes.value) typeAttributes() else annotations() val pos = in.currentPos var t: Tree = - if (in.token == LPAREN && !isPattern) { + if (in.token == LPAREN) { in.nextToken() - val t = typ() + val ts = types(isPattern) accept(RPAREN) - t - } else if (in.token == LBRACE) { - in.nextToken() - val ts = if (in.token == RBRACE) List() - else { - val t1 = argType(isPattern) - accept(COMMA) - t1 :: (if (in.token == RBRACE) List() else argTypes(isPattern, true)) - } - checkSize("tuple elements", ts.length, definitions.MaxTupleArity) - accept(RBRACE) - makeTupleType(ts, false) + atPos(pos) { makeTupleType(ts, true) } } else { val r = path(false, true) val x = r match { @@ -723,29 +702,16 @@ trait Parsers requires SyntaxAnalyzer { else (t /: annots) (makeAnnotated) } - /** TypeArgs ::= `[' ArgTypes `]' - * TypePatternArgs ::= '[' ArgTypePatterns `]' + /** TypeArgs ::= `[' ArgType {`,' ArgType} `]' + * TypePatternArgs ::= '[' ArgTypePattern {`,' ArgTypePattern} `]' */ def typeArgs(isPattern: boolean): List[Tree] = { accept(LBRACKET) - val ts = argTypes(isPattern, false) + val ts = types(isPattern) accept(RBRACKET) ts } - /** ArgTypes ::= ArgType {`,' ArgType} - * ArgTypePatterns ::= ArgTypePattern {`,' ArgTypePattern} - */ - def argTypes(isPattern: boolean, trailingComma: boolean): List[Tree] = { - val ts = new ListBuffer[Tree] + argType(isPattern) - while (in.token == COMMA) { - in.nextToken() - if (!trailingComma || in.token != RBRACE) - ts += argType(isPattern) - } - ts.toList - } - /** ArgType ::= Type * ArgTypePattern ::= varid * | `_' @@ -764,6 +730,7 @@ trait Parsers requires SyntaxAnalyzer { //////// EXPRESSIONS //////////////////////////////////////////////////////// +/* // XX_LIFTED var liftedGenerators = new collection.mutable.ListBuffer[ValFrom] @@ -797,7 +764,7 @@ trait Parsers requires SyntaxAnalyzer { liftedGenerators = savedLiftedGenerators t } - +*/ /** EqualsExpr ::= `=' Expr */ def equalsExpr(): Tree = { @@ -805,19 +772,20 @@ trait Parsers requires SyntaxAnalyzer { expr() } - /** Exprs ::= Expr {`,' Expr} [ `:' `_' `*' ] + /** Exprs ::= Expr {`,' Expr} [`,'] */ - def argExprs(): List[Tree] = { + def exprs(): List[Tree] = { val ts = new ListBuffer[Tree] + argExpr() while (in.token == COMMA) { - in.nextToken(); ts += argExpr() + in.nextToken(); + if (in.token == RPAREN) return List(makeTupleTerm(ts.toList, false)) + ts += argExpr() } ts.toList } /** expression modifiles */ - final val IsArgument = 1 final val IsInBlock = 2 final val ClosureOK = 4 @@ -835,29 +803,27 @@ trait Parsers requires SyntaxAnalyzer { * | [SimpleExpr `.'] Id `=' Expr * | SimpleExpr ArgumentExprs `=' Expr * | `.' SimpleExpr - * | PostfixExpr [`:' CompoundType] + * | PostfixExpr [`:' (CompoundType | `_' `*')] * | PostfixExpr match [`!'] `{' CaseClauses `}' * | MethodClosure * Bindings ::= `(' [Binding {`,' Binding}] `)' * Binding ::= Id [`:' Type] */ def expr(): Tree = - liftingScope(exprImpl(ClosureOK)) + exprImpl(ClosureOK) def blockStatExpr(): Tree = { - liftingScope(exprImpl(IsInBlock | ClosureOK)) + exprImpl(IsInBlock | ClosureOK) } def argExpr(): Tree = { - exprImpl(IsArgument | ClosureOK) + exprImpl(ClosureOK) } def localExpr(): Tree = { exprImpl(ClosureOK) } - def expr1(): Tree = exprImpl(0) - private def exprImpl(mode: int): Tree = in.token match { case IF => val pos = in.skipToken() @@ -892,7 +858,7 @@ trait Parsers requires SyntaxAnalyzer { val lname: Name = unit.fresh.newName("while$") val pos = in.skipToken() accept(LPAREN) - val cond = noLifting(localExpr()) + val cond = localExpr() accept(RPAREN) newLinesOpt() val body = expr() @@ -904,7 +870,7 @@ trait Parsers requires SyntaxAnalyzer { if (isStatSep) in.nextToken() accept(WHILE) accept(LPAREN) - val cond = noLifting(localExpr()) + val cond = localExpr() accept(RPAREN) atPos(pos) { makeDoWhile(lname, body, cond) } case FOR => @@ -929,7 +895,7 @@ trait Parsers requires SyntaxAnalyzer { case DOT => atPos(in.skipToken()) { if (isIdent) { - liftingScope(makeClosure(simpleExpr())) + makeClosure(stripParens(simpleExpr())) // Note: makeClosure does some special treatment of liftedGenerators } else { syntaxErrorOrIncomplete("identifier expected", true) @@ -945,17 +911,16 @@ trait Parsers requires SyntaxAnalyzer { case _ => } } else if (in.token == COLON) { + t = stripParens(t) val pos = in.skipToken() val annots = annotations() - if ((mode & IsArgument) != 0 && in.token == USCORE) { + if (in.token == USCORE) { val pos1 = in.skipToken() if (isIdent && in.name == nme.STAR) { in.nextToken() t = atPos(pos) { Typed(t, atPos(pos1) { Ident(nme.WILDCARD_STAR.toTypeName) }) } - if (in.token != RPAREN) - syntaxErrorOrIncomplete("`)' expected", false) } else { syntaxErrorOrIncomplete("`*' expected", true) } @@ -974,7 +939,7 @@ trait Parsers requires SyntaxAnalyzer { accept(LBRACE) val cases = caseClauses() accept(RBRACE) - Match(t, cases) + Match(stripParens(t), cases) } } if ((mode & ClosureOK) != 0 && in.token == ARROW) { @@ -982,12 +947,12 @@ trait Parsers requires SyntaxAnalyzer { Function(convertToParams(t), if ((mode & IsInBlock) != 0) block() else expr()) } } - t + stripParens(t) } /** PostfixExpr ::= [`.'] InfixExpr [Id [NewLine]] * InfixExpr ::= PrefixExpr - * | InfixExpr Id [NewLine] (InfixExpr | ArgumentExprs) + * | InfixExpr Id [NewLine] InfixExpr */ def postfixExpr(): Tree = { val base = opstack @@ -1000,7 +965,7 @@ trait Parsers requires SyntaxAnalyzer { ident() newLineOptWhenFollowing(isExprIntroToken) if (isExprIntro) { - top = secondInfixOperandExpr(op) + top = prefixExpr() } else { val topinfo = opstack.head opstack = opstack.tail @@ -1012,17 +977,6 @@ trait Parsers requires SyntaxAnalyzer { reduceStack(true, base, top, 0, true) } - def secondInfixOperandExpr(op: Name): Tree = - if (in.token == LPAREN && treeInfo.isLeftAssoc(op)) { - val pos = in.currentPos - val args = argumentExprs() - if (args.isEmpty) simpleExprRest(Literal(()) setPos pos, false) - else if (args.tail.isEmpty) simpleExprRest(args.head, false) - else ArgumentExprs(args) - } else { - prefixExpr() - } - /** PrefixExpr ::= [`-' | `+' | `~' | `!' | `&' | `/'] SimpleExpr */ def prefixExpr(): Tree = @@ -1030,16 +984,16 @@ trait Parsers requires SyntaxAnalyzer { val name = ident() in.token match { case INTLIT | LONGLIT | FLOATLIT | DOUBLELIT => literal(false, true) - case _ => atPos(in.currentPos) { Select(simpleExpr(), name) } + case _ => atPos(in.currentPos) { Select(stripParens(simpleExpr()), name) } } } else if (isIdent && (in.name == PLUS || in.name == TILDE || in.name == BANG)) { val pos = in.currentPos val name = ident() - atPos(pos) { Select(simpleExpr(), name) } + atPos(pos) { Select(stripParens(simpleExpr()), name) } } else if (isIdent && in.name == AMP) { val pos = in.currentPos val name = ident() - atPos(pos) { Typed(simpleExpr(), Function(List(), EmptyTree)) } + atPos(pos) { Typed(stripParens(simpleExpr()), Function(List(), EmptyTree)) } /* XX-LIFTING } else if (settings.Xexperimental.value && isIdent && in.name == SLASH) { val pos = in.skipToken() @@ -1059,6 +1013,7 @@ trait Parsers requires SyntaxAnalyzer { * | StableId `.' class * | `(' [Expr] `)' * | BlockExpr + * | new Template * | SimpleExpr `.' Id * | SimpleExpr TypeArgs * | SimpleExpr1 ArgumentExprs @@ -1076,28 +1031,9 @@ trait Parsers requires SyntaxAnalyzer { t = path(true, false) case LPAREN => val pos = in.skipToken() - if (in.token == RPAREN) { - in.nextToken() - t = Literal(()).setPos(pos) - } else { - t = localExpr() - if (in.token == COMMA) { - val commapos = in.skipToken() - val ts = new ListBuffer[Tree] + t ++ argExprs() - accept(RPAREN) - if (in.token == ARROW) { - t = atPos(pos) { - Function(ts.toList map convertToParam, TypeTree()) - } - } else if(in.token == EOF) { - incompleteInputError("`=>' expected") - } else { - syntaxError(commapos, "`)' expected", false) - } - } else { - accept(RPAREN) - } - } + val ts = if (in.token == RPAREN) List() else exprs() + accept(RPAREN) + t = Parens(ts) case LBRACE => t = blockExpr() case NEW => @@ -1130,7 +1066,7 @@ trait Parsers requires SyntaxAnalyzer { def simpleExprRest(t: Tree, isNew: boolean): Tree = in.token match { case DOT => - simpleExprRest(atPos(in.skipToken()) { selector(t) }, false) + simpleExprRest(atPos(in.skipToken()) { selector(stripParens(t)) }, false) case LBRACKET => t match { case Ident(_) | Select(_, _) => @@ -1139,7 +1075,7 @@ trait Parsers requires SyntaxAnalyzer { t } case LPAREN | LBRACE if (!isNew) => - simpleExprRest(atPos(in.currentPos) { Apply(t, argumentExprs()) }, false) + simpleExprRest(atPos(in.currentPos) { Apply(stripParens(t), argumentExprs()) }, false) case _ => t } @@ -1152,7 +1088,7 @@ trait Parsers requires SyntaxAnalyzer { List(blockExpr()) } else { accept(LPAREN) - val ts = if (in.token == RPAREN) List() else argExprs() + val ts = if (in.token == RPAREN) List() else exprs() accept(RPAREN) ts } @@ -1163,18 +1099,16 @@ trait Parsers requires SyntaxAnalyzer { def blockExpr(): Tree = { val res = atPos(accept(LBRACE)) { if (in.token == CASE) makeVisitor(caseClauses(), true) - else blockOrTuple(true) + else block() } accept(RBRACE) res } /** Block ::= BlockStatSeq - * Tuple ::= [Expr1 `,' {Expr1 `,'} [Expr1]] */ - def block(): Tree = blockOrTuple(false) - def blockOrTuple(tupleOK: boolean): Tree = - makeBlock(blockStatSeqOrTuple(tupleOK, new ListBuffer[Tree])) + def block(): Tree = + makeBlock(blockStatSeq(new ListBuffer[Tree])) /** CaseClauses ::= CaseClause {CaseClause} */ @@ -1191,7 +1125,7 @@ trait Parsers requires SyntaxAnalyzer { atPos(accept(CASE)) { val pat = pattern() val guard = - if (in.token == IF) { in.nextToken(); noLifting(postfixExpr()) } + if (in.token == IF) { in.nextToken(); stripParens(postfixExpr()) } else EmptyTree makeCaseDef(pat, guard, atPos(accept(ARROW))(block())) } @@ -1225,12 +1159,12 @@ trait Parsers requires SyntaxAnalyzer { /** Patterns ::= Pattern { `,' Pattern } */ /** SeqPatterns ::= SeqPattern { `,' SeqPattern } */ - def patterns(seqOK: boolean, trailingComma: boolean): List[Tree] = { - val ts = new ListBuffer[Tree] - ts += pattern(seqOK) + def patterns(seqOK: boolean): List[Tree] = { + val ts = new ListBuffer[Tree] + pattern(seqOK) while (in.token == COMMA) { in.nextToken(); - if (!trailingComma || in.token != RBRACE) ts += pattern(seqOK) + if (in.token == RPAREN) return List(makeTupleTerm(ts.toList, false)) + ts += pattern(seqOK) } ts.toList } @@ -1319,22 +1253,11 @@ trait Parsers requires SyntaxAnalyzer { val op = in.name opstack = OpInfo(top, op, in.currentPos) :: opstack ident() - top = secondInfixOperandPattern(op, seqOK) + top = simplePattern(seqOK) } - reduceStack(false, base, top, 0, true) + stripParens(reduceStack(false, base, top, 0, true)) } - def secondInfixOperandPattern(op: Name, seqOK: boolean): Tree = - if (in.token == LPAREN && treeInfo.isLeftAssoc(op)) { - val pos = in.currentPos - val args = argumentPatterns() - if (args.isEmpty) Literal(()) setPos pos - else if (args.tail.isEmpty) args.head - else ArgumentExprs(args) - } else { - simplePattern(seqOK) - } - /** SimplePattern ::= varid * | `_' * | literal @@ -1373,9 +1296,7 @@ trait Parsers requires SyntaxAnalyzer { } else */ if (in.token == LPAREN) { - atPos(in.currentPos) { Apply(/*convertToTypeId*/(t), argumentPatterns()) } - } else if (in.token == LBRACE) { - atPos(in.currentPos) { Apply(/*convertToTypeId*/(t), List(tuplePattern())) } + atPos(in.currentPos) { Apply(t, argumentPatterns()) } } else t case USCORE => atPos(in.skipToken()) { Ident(nme.WILDCARD) } @@ -1383,15 +1304,9 @@ trait Parsers requires SyntaxAnalyzer { literal(true, false) case LPAREN => val pos = in.skipToken() - val p = - //if (false /*disabled, no regexp matching*/ && seqOK) atPos(pos) { makeSequence(patterns(true, false)) } - //else - if (in.token != RPAREN) pattern(false) - else Literal(()).setPos(pos) + val ps = if (in.token == RPAREN) List() else patterns(false) accept(RPAREN) - p - case LBRACE => - tuplePattern() + Parens(ps) case XMLSTART => xmlp.xLiteralPattern case _ => @@ -1404,24 +1319,11 @@ trait Parsers requires SyntaxAnalyzer { def argumentPatterns(): List[Tree] = { accept(LPAREN) - val ps = if (in.token == RPAREN) List() else patterns(true, false) + val ps = if (in.token == RPAREN) List() else patterns(true) accept(RPAREN) ps } - def tuplePattern(): Tree = { - in.nextToken() - val ts = if (in.token == RBRACE) List() - else { - val p1 = pattern() - accept(COMMA) - p1 :: (if (in.token == RBRACE) List() else patterns(false, true)) - } - checkSize("tuple elements", ts.length, definitions.MaxTupleArity) - accept(RBRACE) - makeTuplePattern(ts) - } - ////////// MODIFIERS //////////////////////////////////////////////////////////// private def normalize(mods: Modifiers): Modifiers = @@ -1706,7 +1608,7 @@ trait Parsers requires SyntaxAnalyzer { def loop: Tree = if (in.token == USCORE) { in.nextToken() - Import(t, List({nme.WILDCARD, null})) + Import(t, List(Pair(nme.WILDCARD, null))) } else if (in.token == LBRACE) { Import(t, importSelectors()) } else { @@ -1716,7 +1618,7 @@ trait Parsers requires SyntaxAnalyzer { pos = accept(DOT) loop } else { - Import(t, List({name, name})) + Import(t, List(Pair(name, name))) } } loop @@ -1724,8 +1626,8 @@ trait Parsers requires SyntaxAnalyzer { /** ImportSelectors ::= `{' {ImportSelector `,'} (ImportSelector | `_') `}' */ - def importSelectors(): List[{Name, Name}] = { - val names = new ListBuffer[{Name, Name}] + def importSelectors(): List[Pair[Name, Name]] = { + val names = new ListBuffer[Pair[Name, Name]] accept(LBRACE) var isLast = importSelector(names) while (!isLast && in.token == COMMA) { @@ -1738,19 +1640,19 @@ trait Parsers requires SyntaxAnalyzer { /** ImportSelector ::= Id [`=>' Id | `=>' `_'] */ - def importSelector(names: ListBuffer[{Name, Name}]): boolean = + def importSelector(names: ListBuffer[Pair[Name, Name]]): boolean = if (in.token == USCORE) { - in.nextToken(); names += {nme.WILDCARD, null}; true + in.nextToken(); names += Pair(nme.WILDCARD, null); true } else { val name = ident() - names += { + names += Pair( name, if (in.token == ARROW) { in.nextToken() if (in.token == USCORE) { in.nextToken(); nme.WILDCARD } else ident() } else { name - }} + }) false } @@ -1788,7 +1690,7 @@ trait Parsers requires SyntaxAnalyzer { var lhs = new ListBuffer[Tree] do { in.nextToken() - lhs += pattern2(false) + lhs += stripParens(pattern2(false)) } while (in.token == COMMA) val tp = typedOpt() val rhs = @@ -1823,9 +1725,9 @@ trait Parsers requires SyntaxAnalyzer { */ def varDefOrDcl(mods: Modifiers): List[Tree] = { var newmods = mods | Flags.MUTABLE - val lhs = new ListBuffer[{Int, Name}] + val lhs = new ListBuffer[Pair[Int, Name]] do { - lhs += {in.skipToken(), ident()} + lhs += Pair(in.skipToken(), ident()) } while (in.token == COMMA) val tp = typedOpt() val rhs = if (tp.isEmpty || in.token == EQUALS) { @@ -1840,7 +1742,7 @@ trait Parsers requires SyntaxAnalyzer { newmods = newmods | Flags.DEFERRED EmptyTree } - for (val {pos, name} <- lhs.toList) yield + for (val Pair(pos, name) <- lhs.toList) yield atPos(pos) { ValDef(newmods, name, tp.duplicate, rhs.duplicate) } } @@ -1963,10 +1865,10 @@ trait Parsers requires SyntaxAnalyzer { implicitClassViews = implicitViewBuf.toList //if (mods.hasFlag(Flags.CASE) && in.token != LPAREN) accept(LPAREN) val constrAnnots = annotations() - val {constrMods, vparamss} = - if (mods.hasFlag(Flags.TRAIT)) {NoMods, List()} - else {accessModifierOpt(), - paramClauses(name, implicitClassViews, mods.hasFlag(Flags.CASE))} + val Pair(constrMods, vparamss) = + if (mods.hasFlag(Flags.TRAIT)) Pair(NoMods, List()) + else Pair(accessModifierOpt(), + paramClauses(name, implicitClassViews, mods.hasFlag(Flags.CASE))) val thistpe = requiresTypeOpt() val template = classTemplate(mods, name, constrMods withAnnotations constrAnnots, vparamss) val mods1 = if (mods.hasFlag(Flags.TRAIT) && @@ -2162,7 +2064,7 @@ trait Parsers requires SyntaxAnalyzer { if (settings.Xplugtypes.value) { while(in.token == LBRACKET) { accept(LBRACKET) - exps ++= argExprs + exps ++= exprs() accept(RBRACKET) } } @@ -2177,7 +2079,7 @@ trait Parsers requires SyntaxAnalyzer { var pos = in.currentPos val aname = atPos(pos) { Ident(ident()) } accept(EQUALS) - atPos(pos) { Assign(aname, liftingScope(prefixExpr())) } + atPos(pos) { Assign(aname, stripParens(prefixExpr())) } } val pos = in.currentPos var t: Tree = convertToTypeId(stableId()) @@ -2222,11 +2124,8 @@ trait Parsers requires SyntaxAnalyzer { * | LocalModifiers TmplDef * | Expr1 * | - * Tuple ::= [Expr1 `,' {Expr1 `,'} [Expr1]] */ - def blockStatSeq(stats: ListBuffer[Tree]): List[Tree] = - blockStatSeqOrTuple(false, stats) - def blockStatSeqOrTuple(tupleOK: boolean, stats: ListBuffer[Tree]): List[Tree] = { + def blockStatSeq(stats: ListBuffer[Tree]): List[Tree] = { def localDef(mods: Modifiers) = { if (!(mods hasFlag ~Flags.IMPLICIT)) stats ++= defOrDcl(mods) else stats += tmplDef(mods) @@ -2243,23 +2142,7 @@ trait Parsers requires SyntaxAnalyzer { stats ++= importClause() acceptStatSep() } else if (isExprIntro) { - val expr = blockStatExpr() - if (in.token == COMMA) { - val exprbuf = new ListBuffer[Tree] + expr - while (in.token == COMMA) { - in.nextToken() - if (in.token != RBRACE) exprbuf += expr1() - } - val exprs = exprbuf.toList - if (in.token == ARROW) { - val vdefs = exprs flatMap convertToParams - checkSize("function arguments", vdefs.length, definitions.MaxFunctionArity) - stats += atPos(in.skipToken()) { Function(vdefs, block()) } - } else { - checkSize("tuple elements:", exprs.length, definitions.MaxTupleArity) - stats += makeTupleTerm(exprs, false) - } - } else stats += expr + stats += blockStatExpr() if (in.token != RBRACE && in.token != CASE) acceptStatSep() } else if (isDefIntro) { localDef(NoMods) diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index e09b18dfd8..b197940207 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -57,16 +57,16 @@ abstract class TreeBuilder { /** Traverse pattern and collect all variable names with their types in buffer */ private object getvarTraverser extends Traverser { - val buf = new ListBuffer[{Name, Tree}] + val buf = new ListBuffer[Pair[Name, Tree]] def init: Traverser = { buf.clear; this } override def traverse(tree: Tree): unit = tree match { case Bind(name, Typed(tree1, tpt)) => if ((name != nme.WILDCARD) && (buf.elements forall (name !=))) - buf += {name, tpt} + buf += Pair(name, tpt) traverse(tree1) case Bind(name, tree1) => if ((name != nme.WILDCARD) && (buf.elements forall (name !=))) - buf += {name, TypeTree()} + buf += Pair(name, TypeTree()) traverse(tree1) case _ => super.traverse(tree) @@ -76,7 +76,7 @@ abstract class TreeBuilder { /** Returns list of all pattern variables, possibly with their types, * without duplicates */ - private def getVariables(tree: Tree): List[{Name, Tree}] = { + private def getVariables(tree: Tree): List[Pair[Name, Tree]] = { getvarTraverser.init.traverse(tree) getvarTraverser.buf.toList } @@ -92,48 +92,48 @@ abstract class TreeBuilder { case _ => makeTuple(trees, false) } - def makeTuplePattern(trees: List[Tree]): Tree = trees match { - case List() => Literal(()) - case _ => makeTuple(trees, false) - } - def makeTupleType(trees: List[Tree], flattenUnary: boolean): Tree = trees match { case List() => scalaUnitConstr case List(tree) if flattenUnary => tree case _ => AppliedTypeTree(scalaDot(newTypeName("Tuple" + trees.length)), trees) } + def stripParens(t: Tree) = t match { + case Parens(ts) => atPos(t.pos) { makeTupleTerm(ts, true) } + case _ => t + } + def makeAnnotated(t: Tree, attr: Tree): Tree = attr match { case Annotation(constr, elements) => Annotated(constr, elements, t) setPos attr.pos } /** If tree is a variable pattern, return Some("its name and type"). * Otherwise return none */ - private def matchVarPattern(tree: Tree): Option[{Name, Tree}] = tree match { - case Ident(name) => Some{name, TypeTree()} - case Bind(name, Ident(nme.WILDCARD)) => Some{name, TypeTree()} - case Typed(Ident(name), tpt) => Some{name, tpt} - case Bind(name, Typed(Ident(nme.WILDCARD), tpt)) => Some{name, tpt} + private def matchVarPattern(tree: Tree): Option[Pair[Name, Tree]] = tree match { + case Ident(name) => Some(Pair(name, TypeTree())) + case Bind(name, Ident(nme.WILDCARD)) => Some(Pair(name, TypeTree())) + case Typed(Ident(name), tpt) => Some(Pair(name, tpt)) + case Bind(name, Typed(Ident(nme.WILDCARD), tpt)) => Some(Pair(name, tpt)) case _ => None } /** Create tree representing (unencoded) binary operation expression or pattern. */ def makeBinop(isExpr: boolean, left: Tree, op: Name, right: Tree): Tree = { val arguments = right match { - case ArgumentExprs(args) => args + case Parens(args) => args case _ => List(right) } if (isExpr) { if (treeInfo.isLeftAssoc(op)) { - Apply(Select(left, op.encode), arguments) + Apply(Select(stripParens(left), op.encode), arguments) } else { val x = freshName(); Block( - List(ValDef(Modifiers(SYNTHETIC), x, TypeTree(), left)), - Apply(Select(right, op.encode), List(Ident(x)))) + List(ValDef(Modifiers(SYNTHETIC), x, TypeTree(), stripParens(left))), + Apply(Select(stripParens(right), op.encode), List(Ident(x)))) } } else { - Apply(Ident(op.encode), left :: arguments) + Apply(Ident(op.encode), stripParens(left) :: arguments) } } @@ -259,7 +259,7 @@ abstract class TreeBuilder { private def makeFor(mapName: Name, flatMapName: Name, enums: List[Enumerator], body: Tree): Tree = { def makeClosure(pat: Tree, body: Tree): Tree = matchVarPattern(pat) match { - case Some{name, tpt} => + case Some(Pair(name, tpt)) => Function(List(ValDef(Modifiers(PARAM), name, tpt, EmptyTree)), body) case None => makeVisitor(List(CaseDef(pat, EmptyTree, body)), false) @@ -385,7 +385,7 @@ abstract class TreeBuilder { /** Create tree for pattern definition <mods val pat0 = rhs> */ def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree): List[Tree] = matchVarPattern(pat) match { - case Some{name, tpt} => + case Some(Pair(name, tpt)) => List(ValDef(mods, name, tpt, rhs)) case None => @@ -410,13 +410,13 @@ abstract class TreeBuilder { vars match { case List() => List(matchExpr) - case List{vname, tpt} => + case List(Pair(vname, tpt)) => List(ValDef(mods, vname, tpt, matchExpr)) case _ => val tmp = freshName() val firstDef = ValDef(Modifiers(PRIVATE | LOCAL | SYNTHETIC), tmp, TypeTree(), matchExpr) var cnt = 0 - val restDefs = for (val {vname, tpt} <- vars) yield { + val restDefs = for (val Pair(vname, tpt) <- vars) yield { cnt = cnt + 1 ValDef(mods, vname, tpt, Select(Ident(tmp), newTermName("_" + cnt))) } @@ -448,5 +448,5 @@ abstract class TreeBuilder { makePackaging(qual, List(PackageDef(name, stats))) } - case class ArgumentExprs(args: List[Tree]) extends Tree + case class Parens(args: List[Tree]) extends Tree } diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 2622be079a..0219442b8a 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -484,34 +484,34 @@ abstract class GenICode extends SubComponent { val kind = toTypeKind(tree.tpe) var handlers = for (val CaseDef(pat, _, body) <- catches.reverse) yield pat match { - case Typed(Ident(nme.WILDCARD), tpt) => {tpt.tpe.symbol, kind, { + case Typed(Ident(nme.WILDCARD), tpt) => Triple(tpt.tpe.symbol, kind, { ctx: Context => ctx.bb.emit(DROP(REFERENCE(tpt.tpe.symbol))); val ctx1 = genLoad(body, ctx, kind); genLoad(finalizer, ctx1, UNIT); - }} + }) - case Ident(nme.WILDCARD) => {definitions.ThrowableClass, kind, { + case Ident(nme.WILDCARD) => Triple(definitions.ThrowableClass, kind, { ctx: Context => ctx.bb.emit(DROP(REFERENCE(definitions.ThrowableClass))) val ctx1 = genLoad(body, ctx, kind) genLoad(finalizer, ctx1, UNIT) - }} + }) case Bind(name, _) => val exception = new Local(pat.symbol, toTypeKind(pat.symbol.tpe), false) ctx.method.addLocal(exception); - {pat.symbol.tpe.symbol, kind, { + Triple(pat.symbol.tpe.symbol, kind, { ctx: Context => ctx.bb.emit(STORE_LOCAL(exception), pat.pos); val ctx1 = genLoad(body, ctx, kind); genLoad(finalizer, ctx1, UNIT); - }} + }) } if (finalizer != EmptyTree) - handlers = { NoSymbol, kind, { + handlers = Triple(NoSymbol, kind, { ctx: Context => val exception = new Local(ctx.method.symbol .newVariable(finalizer.pos, unit.fresh.newName("exc")) @@ -525,7 +525,7 @@ abstract class GenICode extends SubComponent { ctx1.bb.emit(THROW()); ctx1.bb.enterIgnoreMode; ctx1 - }} :: handlers; + }) :: handlers; ctx.Try( bodyCtx => { @@ -1273,9 +1273,9 @@ abstract class GenICode extends SubComponent { def genComparisonOp(l: Tree, r: Tree, code: Int): Unit = { // special-case reference (in)equality test for null if (code == scalaPrimitives.ID || code == scalaPrimitives.NI) { - val expr: Tree = {l, r} match { - case {Literal(Constant(null)), expr} => expr - case {expr, Literal(Constant(null))} => expr + val expr: Tree = Pair(l, r) match { + case Pair(Literal(Constant(null)), expr) => expr + case Pair(expr, Literal(Constant(null))) => expr case _ => null } if (expr ne null) { @@ -1393,15 +1393,15 @@ abstract class GenICode extends SubComponent { local } - {l, r} match { + Pair(l, r) match { // null == expr -> expr eq null - case {Literal(Constant(null)), expr} => + case Pair(Literal(Constant(null)), expr) => val ctx1 = genLoad(expr, ctx, ANY_REF_CLASS) ctx1.bb.emit(CZJUMP(thenCtx.bb, elseCtx.bb, EQ, ANY_REF_CLASS)) ctx1.bb.close // expr == null -> if(expr eq null) true else expr.equals(null) - case {expr, Literal(Constant(null))} => + case Pair(expr, Literal(Constant(null))) => val eqEqTempLocal = getTempLocal var ctx1 = genLoad(expr, ctx, ANY_REF_CLASS) ctx1.bb.emit(DUP(ANY_REF_CLASS)) @@ -1808,7 +1808,7 @@ abstract class GenICode extends SubComponent { * } )) */ def Try(body: Context => Context, - handlers: List[{Symbol, TypeKind, (Context => Context)}], + handlers: List[Triple[Symbol, TypeKind, (Context => Context)]], finalizer: Tree) = { val outerCtx = this.dup val afterCtx = outerCtx.newBlock diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala index 6116b73d1e..0f8d1091a1 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Members.scala @@ -229,7 +229,7 @@ trait Members requires ICodes { var end: Int = _ /** PC-based ranges for this local variable's visibility range */ - var ranges: List[{Int, Int}] = Nil + var ranges: List[Pair[Int, Int]] = Nil override def equals(other: Any): Boolean = ( other.isInstanceOf[Local] && diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index d412a4315e..0a4de0e814 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -203,7 +203,7 @@ abstract class GenJVM extends SubComponent { } def addExceptionsAttribute(sym: Symbol): Unit = { - val {excs, others} = sym.attributes.partition((a => a match { + val Pair(excs, others) = sym.attributes.partition((a => a match { case AttrInfo(ThrowsAttr, _, _) => true case _ => false })) @@ -289,7 +289,7 @@ abstract class GenJVM extends SubComponent { buf.putShort(cpool.addUtf8("value").toShort) emitElement(consts.head) } - for (val {name, value} <- nvPairs) { + for (val Pair(name, value) <- nvPairs) { buf.putShort(cpool.addUtf8(name.toString()).toShort) emitElement(value) } @@ -593,7 +593,7 @@ abstract class GenJVM extends SubComponent { if (! (covered contains b) ) { if (start >= 0) { // we're inside a handler range end = labels(b).getAnchor() - ranges = {start, end} :: ranges + ranges = Pair(start, end) :: ranges start = -1 } } else { @@ -612,7 +612,7 @@ abstract class GenJVM extends SubComponent { * code! */ if (start >= 0) { - ranges = {start, jcode.getPC()} :: ranges; + ranges = Pair(start, jcode.getPC()) :: ranges; } if (covered != Nil) @@ -989,10 +989,10 @@ abstract class GenJVM extends SubComponent { case SCOPE_EXIT(lv) => if (varsInBlock contains lv) { - lv.ranges = {lv.start, jcode.getPC()} :: lv.ranges + lv.ranges = Pair(lv.start, jcode.getPC()) :: lv.ranges varsInBlock -= lv } else if (b.varsInScope contains lv) { - lv.ranges = {labels(b).getAnchor(), jcode.getPC()} :: lv.ranges + lv.ranges = Pair(labels(b).getAnchor(), jcode.getPC()) :: lv.ranges b.varsInScope -= lv } else assert(false, "Illegal local var nesting: " + method) @@ -1022,10 +1022,10 @@ abstract class GenJVM extends SubComponent { // local vars that survived this basic block for (val lv <- varsInBlock) { - lv.ranges = {lv.start, jcode.getPC()} :: lv.ranges + lv.ranges = Pair(lv.start, jcode.getPC()) :: lv.ranges } for (val lv <- b.varsInScope) { - lv.ranges = {labels(b).getAnchor(), jcode.getPC()} :: lv.ranges + lv.ranges = Pair(labels(b).getAnchor(), jcode.getPC()) :: lv.ranges } } @@ -1101,67 +1101,67 @@ abstract class GenJVM extends SubComponent { abort("Unknown arithmetic primitive " + primitive) } - case Logical(op, kind) => {op, kind} match { - case {AND, LONG} => + case Logical(op, kind) => Pair(op, kind) match { + case Pair(AND, LONG) => jcode.emitLAND() - case {AND, INT} => + case Pair(AND, INT) => jcode.emitIAND() - case {AND, _} => + case Pair(AND, _) => jcode.emitIAND() if (kind != BOOL) jcode.emitT2T(javaType(INT), javaType(kind)); - case {OR, LONG} => + case Pair(OR, LONG) => jcode.emitLOR() - case {OR, INT} => + case Pair(OR, INT) => jcode.emitIOR() - case {OR, _} => + case Pair(OR, _) => jcode.emitIOR() if (kind != BOOL) jcode.emitT2T(javaType(INT), javaType(kind)); - case {XOR, LONG} => + case Pair(XOR, LONG) => jcode.emitLXOR() - case {XOR, INT} => + case Pair(XOR, INT) => jcode.emitIXOR() - case {XOR, _} => + case Pair(XOR, _) => jcode.emitIXOR() if (kind != BOOL) jcode.emitT2T(javaType(INT), javaType(kind)); } - case Shift(op, kind) => {op, kind} match { - case {LSL, LONG} => + case Shift(op, kind) => Pair(op, kind) match { + case Pair(LSL, LONG) => jcode.emitLSHL() - case {LSL, INT} => + case Pair(LSL, INT) => jcode.emitISHL() - case {LSL, _} => + case Pair(LSL, _) => jcode.emitISHL() jcode.emitT2T(javaType(INT), javaType(kind)) - case {ASR, LONG} => + case Pair(ASR, LONG) => jcode.emitLSHR() - case {ASR, INT} => + case Pair(ASR, INT) => jcode.emitISHR() - case {ASR, _} => + case Pair(ASR, _) => jcode.emitISHR() jcode.emitT2T(javaType(INT), javaType(kind)) - case {LSR, LONG} => + case Pair(LSR, LONG) => jcode.emitLUSHR() - case {LSR, INT} => + case Pair(LSR, INT) => jcode.emitIUSHR() - case {LSR, _} => + case Pair(LSR, _) => jcode.emitIUSHR() jcode.emitT2T(javaType(INT), javaType(kind)) } - case Comparison(op, kind) => {op, kind} match { - case {CMP, LONG} => jcode.emitLCMP() - case {CMPL, FLOAT} => jcode.emitFCMPL() - case {CMPG, FLOAT} => jcode.emitFCMPG() - case {CMPL, DOUBLE} => jcode.emitDCMPL() - case {CMPG, DOUBLE} => jcode.emitDCMPL() + case Comparison(op, kind) => Pair(op, kind) match { + case Pair(CMP, LONG) => jcode.emitLCMP() + case Pair(CMPL, FLOAT) => jcode.emitFCMPL() + case Pair(CMPG, FLOAT) => jcode.emitFCMPG() + case Pair(CMPL, DOUBLE) => jcode.emitDCMPL() + case Pair(CMPG, DOUBLE) => jcode.emitDCMPL() } case Conversion(src, dst) => @@ -1449,7 +1449,7 @@ abstract class GenJVM extends SubComponent { val index = indexOf(lv).asInstanceOf[Short] val tpe = javaType(lv.kind).getSignature() - for (val {start, end} <- lv.ranges) { + for (val Pair(start, end) <- lv.ranges) { emitEntry(name, tpe, index, start.asInstanceOf[Short], (end - start).asInstanceOf[Short]) } } @@ -1463,10 +1463,10 @@ abstract class GenJVM extends SubComponent { /** Merge adjacent ranges. */ - private def mergeEntries(ranges: List[{Int, Int}]): List[{Int, Int}] = - (ranges.foldLeft(Nil: List[{Int, Int}]) { (collapsed: List[{Int, Int}], p: {Int, Int}) => {collapsed, p} match { - case { Nil, _ } => List(p) - case { {s1, e1} :: rest, {s2, e2} } if (e1 == s2) => {s1, e2} :: rest + private def mergeEntries(ranges: List[Pair[Int, Int]]): List[Pair[Int, Int]] = + (ranges.foldLeft(Nil: List[Pair[Int, Int]]) { (collapsed: List[Pair[Int, Int]], p: Pair[Int, Int]) => Pair(collapsed, p) match { + case Pair(Nil, _) => List(p) + case Pair(Pair(s1, e1) :: rest, Pair(s2, e2)) if (e1 == s2) => Pair(s1, e2) :: rest case _ => p :: collapsed }}).reverse diff --git a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala index 2d16388b37..3623d125ea 100644 --- a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala +++ b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala @@ -889,7 +889,7 @@ abstract class GenMSIL extends SubComponent { def leavingBlocks(blocks: List[BasicBlock]): List[Pair[BasicBlock, List[BasicBlock]]] = { for {val b <- blocks val t = outsideTargets(b, blocks) - t.length != 0 } yield {b, t} + t.length != 0 } yield Pair(b, t) } def replaceOutJumps(blocks: List[BasicBlock], leaving: List[Pair[BasicBlock, List[BasicBlock]]], exh: ExceptionHandler):Pair[List[BasicBlock], Option[BasicBlock]] = { @@ -926,12 +926,12 @@ abstract class GenMSIL extends SubComponent { val target = p._2(0) // the elemets of p._2 are all the same, checked before replaceJump(lBlock, target, jumpOutBlock) }) - {blocks ::: List(jumpOutBlock), Some(jumpOutBlock)} + Pair(blocks ::: List(jumpOutBlock), Some(jumpOutBlock)) } val leaving = leavingBlocks(blocks) if (leaving.length == 0) - {blocks, None} + Pair(blocks, None) else if (leaving.length == 1) { val outside = leaving(0)._2 assert(outside.forall(b => b == outside(0)), "exception-block leaving to multiple targets") @@ -940,7 +940,7 @@ abstract class GenMSIL extends SubComponent { else assert(firstBlockAfter(exh) == outside(0), "try/catch leaving to multiple targets: " + firstBlockAfter(exh) + ", new: " + outside(0)) val last = leaving(0)._1 - {blocks.diff(List(last)) ::: List(last), None} + Pair(blocks.diff(List(last)) ::: List(last), None) } else { val outside = leaving.flatMap(p => p._2) assert(outside.forall(b => b == outside(0)), "exception-block leaving to multiple targets") @@ -968,7 +968,7 @@ abstract class GenMSIL extends SubComponent { var singleAffectedHandler: ExceptionHandler = affectedHandlers(0) // List[ExceptionHandler] = Nil var exceptionBlock: Option[ExceptionBlock] = None affectedHandlers.foreach(h1 => { - val {adaptedBlocks, newBlock} = adaptBlocks(blocksToPut.intersect(h1.blocks), singleAffectedHandler) + val Pair(adaptedBlocks, newBlock) = adaptBlocks(blocksToPut.intersect(h1.blocks), singleAffectedHandler) newBlock match { case Some(block) => blocksToPut = blocksToPut ::: List(block) @@ -986,7 +986,7 @@ abstract class GenMSIL extends SubComponent { val excBlock = currentBlock.addExceptionBlock(singleAffectedHandler) exceptionBlock = Some(excBlock) - val {tryBlocks, newBlock} = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.covered), singleAffectedHandler) + val Pair(tryBlocks, newBlock) = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.covered), singleAffectedHandler) newBlock match { case Some(block) => @@ -998,7 +998,7 @@ abstract class GenMSIL extends SubComponent { addBlocks(tryBlocks) if (singleAffectedHandler.finalizer != null && singleAffectedHandler.finalizer != NoFinalizer) { - val {blocks0, newBlock} = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.finalizer.blocks), singleAffectedHandler) + val Pair(blocks0, newBlock) = adaptBlocks(blocksToPut.intersect(singleAffectedHandler.finalizer.blocks), singleAffectedHandler) newBlock match { case Some(block) => blocksToPut = blocksToPut ::: List(block) @@ -1379,13 +1379,13 @@ abstract class GenMSIL extends SubComponent { } // method: implicit view(FunctionX[PType0, PType1, ...,PTypeN, ResType]):DelegateType - val {isDelegateView, paramType, resType} = atPhase(currentRun.typerPhase){ + val Triple(isDelegateView, paramType, resType) = atPhase(currentRun.typerPhase){ msym.tpe match { case MethodType(parameterTypes, resultType) if (parameterTypes.length == 1 && msym.name == nme.view_) => val isDel = definitions.isCorrespondingDelegate(resultType, parameterTypes(0)) - {isDel, parameterTypes(0), resultType} - case _ => {false, null, null} + Triple(isDel, parameterTypes(0), resultType) + case _ => Triple(false, null, null) } } if (doEmit && isDelegateView) { @@ -2206,8 +2206,8 @@ abstract class GenMSIL extends SubComponent { // create the static caller method and the delegate object - val {paramTypes, returnType} = delegateType.member(nme.apply).tpe match { - case MethodType(delParams, delReturn) => {delParams, delReturn} + val Pair(paramTypes, returnType) = delegateType.member(nme.apply).tpe match { + case MethodType(delParams, delReturn) => Pair(delParams, delReturn) case _ => abort("not a delegate type: " + delegateType) } val caller: MethodBuilder = delegateCallers.DefineMethod( diff --git a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala index c66c3e1ff8..75ab5623fd 100644 --- a/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala +++ b/src/compiler/scala/tools/nsc/matching/PatternMatchers.scala @@ -1044,7 +1044,7 @@ print() //Console.println("sel:"+selector+" last"+lastSelector+" - "+(selector == lastSelector)) val next = _h.next; //res = And(mkNegate(res), toTree(node.or, selector)); - val {doOptimize, coveredCases, remainingCases} = _h.optimize1() + val Triple(doOptimize, coveredCases, remainingCases) = _h.optimize1() if(!remainingCases.isEmpty && doCheckExhaustive) { carryCovered = carryCovered ++ coveredCases // ?? if(next != null && next.or.and.isUnguardedBody) { @@ -1301,7 +1301,7 @@ print() true case _ => if(settings.XprintOuterMatches.value) - cunit.warning(node.pos, "can't be sure statically that these outers are equal:"+{left,right}.toString) + cunit.warning(node.pos, "can't be sure statically that these outers are equal:"+Pair(left,right).toString) false } diff --git a/src/compiler/scala/tools/nsc/matching/PatternNodes.scala b/src/compiler/scala/tools/nsc/matching/PatternNodes.scala index cd0d5da3d8..b436dccefb 100644 --- a/src/compiler/scala/tools/nsc/matching/PatternNodes.scala +++ b/src/compiler/scala/tools/nsc/matching/PatternNodes.scala @@ -327,16 +327,16 @@ trait PatternNodes requires transform.ExplicitOuter { /** returns true if this tree is optimizable * throws a warning if is not exhaustive */ - def optimize1(): { Boolean, SymSet, SymSet } = { + def optimize1(): Triple[Boolean, SymSet, SymSet] = { import symtab.Flags val selType = this.getTpe if (!isSubType(selType, definitions.ScalaObjectClass.tpe)) - return {false, null, emptySymbolSet}; + return Triple(false, null, emptySymbolSet) if(this.or eq null) - return {false, null, emptySymbolSet} // only case _ + return Triple(false, null, emptySymbolSet) // only case _ def checkExCoverage(tpesym:Symbol): SymSet = if(!tpesym.hasFlag(Flags.SEALED)) emptySymbolSet @@ -409,7 +409,7 @@ trait PatternNodes requires transform.ExplicitOuter { } this.forEachBranch(traverse) - return {res && (cases > 2), coveredCases, remainingCases}; + return Triple(res && (cases > 2), coveredCases, remainingCases) } // def optimize } diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 178c6155fa..8fe03975f3 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -174,7 +174,7 @@ abstract class SymbolLoaders { } // do classes first - for (val {name, file} <- classes.elements) { + for (val Pair(name, file) <- classes.elements) { val loader = if (!file.isSourceFile) { new ClassfileLoader(file.classFile, file.sourceFile, file.sourcePath) } else { @@ -184,7 +184,7 @@ abstract class SymbolLoaders { enterClassAndModule(name, loader) } - for (val {name, file} <- packages.elements) + for (val Pair(name, file) <- packages.elements) enterPackage(name, newPackageLoader(file)) } } diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index fad85cfc4a..2db48eaa41 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -1306,7 +1306,7 @@ trait Symbols requires SymbolTable { def cloneSymbolImpl(owner: Symbol): Symbol = throw new Error() } - case class AttrInfo(atp: Type, args: List[Constant], assocs: List[{Name, Constant}]) { + case class AttrInfo(atp: Type, args: List[Constant], assocs: List[Pair[Name, Constant]]) { override def toString: String = atp + (if (args.isEmpty) "" else args.mkString("(", ", ", ")")) + diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 348f9c2f77..27bc11ff67 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -918,7 +918,7 @@ trait Types requires SymbolTable { def apply(tp: Type): Type = { tp match { case TypeRef(_, sym, args) => - for (val {tparam1, arg} <- sym.info.typeParams zip args) + for (val Pair(tparam1, arg) <- sym.info.typeParams zip args) if (arg contains tparam) { addRef(NonExpansive, tparam, tparam1) if (arg.symbol != tparam) addRef(Expansive, tparam, tparam1) @@ -943,7 +943,7 @@ trait Types requires SymbolTable { val lastRefs = Array(refs(0), refs(1)) state = Initialized var change = false - for (val {from, targets} <- refs(NonExpansive).elements) + for (val Pair(from, targets) <- refs(NonExpansive).elements) for (val target <- targets) { var thatInfo = classInfo(target) if (thatInfo.state != Initialized) @@ -951,7 +951,7 @@ trait Types requires SymbolTable { addRefs(NonExpansive, from, thatInfo.getRefs(NonExpansive, target)) addRefs(Expansive, from, thatInfo.getRefs(Expansive, target)) } - for (val {from, targets} <- refs(Expansive).elements) + for (val Pair(from, targets) <- refs(Expansive).elements) for (val target <- targets) { var thatInfo = classInfo(target) addRefs(Expansive, from, thatInfo.getRefs(NonExpansive, target)) @@ -2012,40 +2012,40 @@ trait Types requires SymbolTable { * equivalent types. */ def isSameType(tp1: Type, tp2: Type): boolean = { - {tp1, tp2} match { - case {ErrorType, _} => true - case {WildcardType, _} => true - case {_, ErrorType} => true - case {_, WildcardType} => true - - case {NoType, _} => false - case {NoPrefix, _} => tp2.symbol.isPackageClass - case {_, NoType} => false - case {_, NoPrefix} => tp1.symbol.isPackageClass - - case {ThisType(sym1), ThisType(sym2)} + Pair(tp1, tp2) match { + case Pair(ErrorType, _) => true + case Pair(WildcardType, _) => true + case Pair(_, ErrorType) => true + case Pair(_, WildcardType) => true + + case Pair(NoType, _) => false + case Pair(NoPrefix, _) => tp2.symbol.isPackageClass + case Pair(_, NoType) => false + case Pair(_, NoPrefix) => tp1.symbol.isPackageClass + + case Pair(ThisType(sym1), ThisType(sym2)) if (sym1 == sym2) => true - case {SingleType(pre1, sym1), SingleType(pre2, sym2)} + case Pair(SingleType(pre1, sym1), SingleType(pre2, sym2)) if ((sym1 == sym2) && (pre1 =:= pre2)) => true /* - case {SingleType(pre1, sym1), ThisType(sym2)} + case Pair(SingleType(pre1, sym1), ThisType(sym2)) if (sym1.isModule && sym1.moduleClass == sym2 && pre1 =:= sym2.owner.thisType) => true - case {ThisType(sym1), SingleType(pre2, sym2)} + case Pair(ThisType(sym1), SingleType(pre2, sym2)) if (sym2.isModule && sym2.moduleClass == sym1 && pre2 =:= sym1.owner.thisType) => true */ - case {ConstantType(value1), ConstantType(value2)} => + case Pair(ConstantType(value1), ConstantType(value2)) => value1 == value2 - case {TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)} => + case Pair(TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) => sym1 == sym2 && (phase.erasedTypes || pre1 =:= pre2) && isSameTypes(args1, args2) - case {RefinedType(parents1, ref1), RefinedType(parents2, ref2)} => + case Pair(RefinedType(parents1, ref1), RefinedType(parents2, ref2)) => def isSubScope(s1: Scope, s2: Scope): boolean = s2.toList.forall { sym2 => val sym1 = s1.lookup(sym2.name) @@ -2054,31 +2054,31 @@ trait Types requires SymbolTable { } //Console.println("is same? " + tp1 + " " + tp2 + " " + tp1.symbol.owner + " " + tp2.symbol.owner)//DEBUG isSameTypes(parents1, parents2) && isSubScope(ref1, ref2) && isSubScope(ref2, ref1) - case {MethodType(pts1, res1), MethodType(pts2, res2)} => + case Pair(MethodType(pts1, res1), MethodType(pts2, res2)) => (pts1.length == pts2.length && isSameTypes(pts1, pts2) && res1 =:= res2 && tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType]) - case {PolyType(tparams1, res1), PolyType(tparams2, res2)} => + case Pair(PolyType(tparams1, res1), PolyType(tparams2, res2)) => (tparams1.length == tparams2.length && List.forall2(tparams1, tparams2) ((p1, p2) => p1.info =:= p2.info.substSym(tparams2, tparams1)) && res1 =:= res2.substSym(tparams2, tparams1)) - case {TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)} => + case Pair(TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) => lo1 =:= lo2 && hi1 =:= hi2 - case {BoundedWildcardType(bounds), _} => + case Pair(BoundedWildcardType(bounds), _) => bounds containsType tp2 - case {_, BoundedWildcardType(bounds)} => + case Pair(_, BoundedWildcardType(bounds)) => bounds containsType tp1 - case {TypeVar(_, constr1), _} => + case Pair(TypeVar(_, constr1), _) => if (constr1.inst != NoType) constr1.inst =:= tp2 else constr1 instantiate (wildcardToTypeVarMap(tp2)) - case {_, TypeVar(_, constr2)} => + case Pair(_, TypeVar(_, constr2)) => if (constr2.inst != NoType) tp1 =:= constr2.inst else constr2 instantiate (wildcardToTypeVarMap(tp1)) - case {AttributedType(_,atp), _} => + case Pair(AttributedType(_,atp), _) => isSameType(atp, tp2) - case {_, AttributedType(_,atp)} => + case Pair(_, AttributedType(_,atp)) => isSameType(tp1, atp) case _ => if (tp1.isStable && tp2.isStable) { @@ -2127,24 +2127,24 @@ trait Types requires SymbolTable { * @return ... */ def isSubType0(tp1: Type, tp2: Type): boolean = { - {tp1, tp2} match { - case {ErrorType, _} => true - case {WildcardType, _} => true - case {_, ErrorType} => true - case {_, WildcardType} => true - - case {NoType, _} => false - case {NoPrefix, _} => tp2.symbol.isPackageClass - case {_, NoType} => false - case {_, NoPrefix} => tp1.symbol.isPackageClass - - case {ThisType(_), ThisType(_)} => tp1 =:= tp2 - case {ThisType(_), SingleType(_, _)} => tp1 =:= tp2 - case {SingleType(_, _), ThisType(_)} => tp1 =:= tp2 - case {SingleType(_, _), SingleType(_, _)} => tp1 =:= tp2 - case {ConstantType(_), ConstantType(_)} => tp1 =:= tp2 - - case {TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)} => + Pair(tp1, tp2) match { + case Pair(ErrorType, _) => true + case Pair(WildcardType, _) => true + case Pair(_, ErrorType) => true + case Pair(_, WildcardType) => true + + case Pair(NoType, _) => false + case Pair(NoPrefix, _) => tp2.symbol.isPackageClass + case Pair(_, NoType) => false + case Pair(_, NoPrefix) => tp1.symbol.isPackageClass + + case Pair(ThisType(_), ThisType(_)) => tp1 =:= tp2 + case Pair(ThisType(_), SingleType(_, _)) => tp1 =:= tp2 + case Pair(SingleType(_, _), ThisType(_)) => tp1 =:= tp2 + case Pair(SingleType(_, _), SingleType(_, _)) => tp1 =:= tp2 + case Pair(ConstantType(_), ConstantType(_)) => tp1 =:= tp2 + + case Pair(TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) => //Console.println("isSubType " + tp1 + " " + tp2);//DEBUG def isSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol]): boolean = ( @@ -2172,50 +2172,50 @@ trait Types requires SymbolTable { || // Console.println("last chance " + sym1 + " " + sym2 + " " + sym2.isClass + " " (sym2 isSubClass ObjectClass)) sym1 == AllRefClass && sym2.isClass && sym2 != AllClass && (sym2 isSubClass ObjectClass)) - case {MethodType(pts1, res1), MethodType(pts2, res2)} => + case Pair(MethodType(pts1, res1), MethodType(pts2, res2)) => (pts1.length == pts2.length && matchingParams(pts1, pts2, tp2.isInstanceOf[JavaMethodType]) && (res1 <:< res2) && tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType]) - case {PolyType(tparams1, res1), PolyType(tparams2, res2)} => + case Pair(PolyType(tparams1, res1), PolyType(tparams2, res2)) => (tparams1.length == tparams2.length && List.forall2(tparams1, tparams2) ((p1, p2) => p2.info.substSym(tparams2, tparams1) <:< p1.info) && res1 <:< res2.substSym(tparams2, tparams1)) - case {TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)} => + case Pair(TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) => lo2 <:< lo1 && hi1 <:< hi2 - case {BoundedWildcardType(bounds), _} => + case Pair(BoundedWildcardType(bounds), _) => bounds.lo <:< tp2 - case {_, BoundedWildcardType(bounds)} => + case Pair(_, BoundedWildcardType(bounds)) => tp1 <:< bounds.hi - case {_, TypeVar(_, constr2)} => + case Pair(_, TypeVar(_, constr2)) => if (constr2.inst != NoType) tp1 <:< constr2.inst else { constr2.lobounds = tp1 :: constr2.lobounds; true } - case {TypeVar(_, constr1), _} => + case Pair(TypeVar(_, constr1), _) => if (constr1.inst != NoType) constr1.inst <:< tp2 else { constr1.hibounds = tp2 :: constr1.hibounds; true } - case {AttributedType(_,atp1), _} => + case Pair(AttributedType(_,atp1), _) => atp1 <:< tp2 - case {_, AttributedType(_,atp2)} => + case Pair(_, AttributedType(_,atp2)) => tp1 <:< atp2 - case {_, TypeRef(pre2, sym2, args2)} + case Pair(_, TypeRef(pre2, sym2, args2)) if sym2.isAbstractType && !(tp2 =:= tp2.bounds.lo) && (tp1 <:< tp2.bounds.lo) => true - case {_, RefinedType(parents2, ref2)} => + case Pair(_, RefinedType(parents2, ref2)) => (parents2 forall tp1.<:<) && (ref2.toList forall tp1.specializes) && (!parents2.exists(.symbol.isAbstractType) || tp1.symbol != AllRefClass) - case {RefinedType(parents1, ref1), _} => + case Pair(RefinedType(parents1, ref1), _) => parents1 exists (.<:<(tp2)) /* todo: replace following with - case {ThisType(_), _} + case Pair(ThisType(_), _) | {SingleType(_, _), _} | {ConstantType(_), _} => once patern matching bug is fixed */ - case {ThisType(_), _} => tp1.singleDeref <:< tp2 - case {SingleType(_, _), _} => tp1.singleDeref <:< tp2 - case {ConstantType(_), _} => tp1.singleDeref <:< tp2 + case Pair(ThisType(_), _) => tp1.singleDeref <:< tp2 + case Pair(SingleType(_, _), _) => tp1.singleDeref <:< tp2 + case Pair(ConstantType(_), _) => tp1.singleDeref <:< tp2 - case {TypeRef(pre1, sym1, args1), _} => + case Pair(TypeRef(pre1, sym1, args1), _) => (sym1 == AllClass && tp2 <:< AnyClass.tpe || sym1 == AllRefClass && tp2.isInstanceOf[SingletonType] && (tp1 <:< tp2.widen)) @@ -2260,21 +2260,21 @@ trait Types requires SymbolTable { } /** A function implementing tp1 matches tp2 */ - private def matchesType(tp1: Type, tp2: Type): boolean = {tp1, tp2} match { - case {MethodType(pts1, res1), MethodType(pts2, res2)} => + private def matchesType(tp1: Type, tp2: Type): boolean = Pair(tp1, tp2) match { + case Pair(MethodType(pts1, res1), MethodType(pts2, res2)) => (matchingParams(pts1, pts2, tp2.isInstanceOf[JavaMethodType]) && (res1 matches res2) && tp1.isInstanceOf[ImplicitMethodType] == tp2.isInstanceOf[ImplicitMethodType]) - case {PolyType(tparams1, res1), PolyType(tparams2, res2)} => + case Pair(PolyType(tparams1, res1), PolyType(tparams2, res2)) => (tparams1.length == tparams2.length && (res1 matches res2.substSym(tparams2, tparams1))) - case {PolyType(List(), rtp1), MethodType(List(), rtp2)} => matchesType(rtp1, rtp2) - case {MethodType(List(), rtp1), PolyType(List(), rtp2)} => matchesType(rtp1, rtp2) - case {PolyType(List(), rtp1), _} => matchesType(rtp1, tp2) - case {_, PolyType(List(), rtp2)} => matchesType(tp1, rtp2) - case {MethodType(_, _), _} => false - case {PolyType(_, _), _} => false - case {_, MethodType(_, _)} => false - case {_, PolyType(_, _)} => false + case Pair(PolyType(List(), rtp1), MethodType(List(), rtp2)) => matchesType(rtp1, rtp2) + case Pair(MethodType(List(), rtp1), PolyType(List(), rtp2)) => matchesType(rtp1, rtp2) + case Pair(PolyType(List(), rtp1), _) => matchesType(rtp1, tp2) + case Pair(_, PolyType(List(), rtp2)) => matchesType(tp1, rtp2) + case Pair(MethodType(_, _), _) => false + case Pair(PolyType(_, _), _) => false + case Pair(_, MethodType(_, _)) => false + case Pair(_, PolyType(_, _)) => false case _ => !phase.erasedTypes || tp1 =:= tp2 } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index 8c0833e3bf..cf53db37a2 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -193,7 +193,7 @@ abstract class ClassfileParser { in.buf(start) != CONSTANT_METHODREF && in.buf(start) != CONSTANT_INTFMETHODREF) errorBadTag(start) val ownerTpe = getClassOrArrayType(in.getChar(start + 1)) - val {name, tpe} = getNameAndType(in.getChar(start + 3), ownerTpe) + val Pair(name, tpe) = getNameAndType(in.getChar(start + 3), ownerTpe) if (name == nme.MODULE_INSTANCE_FIELD) { val index = in.getChar(start + 1) val name = getExternalName(in.getChar(starts(index) + 1)) @@ -232,7 +232,7 @@ abstract class ClassfileParser { tpe = MethodType(formals, ownerTpe) } - p = {name, tpe} + p = Pair(name, tpe) } p } @@ -700,7 +700,7 @@ abstract class ClassfileParser { val nvpairs = new ListBuffer[Pair[Name,Constant]] for (val i <- 0 until nargs) { val name = pool.getName(in.nextChar) - nvpairs += {name, parseTaggedConstant()} + nvpairs += Pair(name, parseTaggedConstant()) } sym.attributes = AttrInfo(attrType, List(), nvpairs.toList) :: sym.attributes } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 68c504eb30..ebe7c6d763 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -169,15 +169,15 @@ abstract class Pickler extends SubComponent { } private def putChildren(sym: Symbol, children: Set[Symbol]): unit = { - assert(putEntry{sym, children}) + assert(putEntry(Pair(sym, children))) children foreach putSymbol } private def putAnnotation(sym: Symbol, attr: AttrInfo): unit = { - assert(putEntry{sym, attr}) + assert(putEntry(Pair(sym, attr))) putType(attr.atp) for (val c <- attr.args) putConstant(c) - for (val {name, c} <- attr.assocs) { putEntry(name); putConstant(c) } + for (val Pair(name, c) <- attr.assocs) { putEntry(name); putConstant(c) } } // Phase 2 methods: Write all entries to byte array ------------------------------ @@ -279,13 +279,13 @@ abstract class Pickler extends SubComponent { LITERAL + c.tag case AttributedType(attribs, tp) => writeBody(tp) // obviously, this should be improved - case {target: Symbol, attr @ AttrInfo(atp, args, assocs)} => + case Pair(target: Symbol, attr @ AttrInfo(atp, args, assocs)) => writeRef(target) writeRef(atp) for (val c <- args) writeRef(c) - for (val {name, c} <- assocs) { writeRef(name); writeRef(c) } + for (val Pair(name, c) <- assocs) { writeRef(name); writeRef(c) } ATTRIBUTE - case {target: Symbol, children: Set[_]} => + case Pair(target: Symbol, children: Set[_]) => writeRef(target) for (val c <- children) writeRef(c.asInstanceOf[Symbol]) CHILDREN diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala index e28ed90b69..ac1d10e9be 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala @@ -288,10 +288,10 @@ abstract class UnPickler { if (tag == ATTRIBUTE) { val attrType = readTypeRef() val args = new ListBuffer[Constant] - val assocs = new ListBuffer[{Name, Constant}] + val assocs = new ListBuffer[Pair[Name, Constant]] while (readIndex != end) { val argref = readNat() - if (isNameEntry(argref)) assocs += {at(argref, readName), readConstantRef()} + if (isNameEntry(argref)) assocs += Pair(at(argref, readName), readConstantRef()) else args += at(argref, readConstant) } val attr = AttrInfo(attrType, args.toList, assocs.toList) diff --git a/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala b/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala index 1610d237e0..7323b17fa3 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ConstantFolder.scala @@ -49,21 +49,21 @@ abstract class ConstantFolder { // compiler itself crashing } - private def foldUnop(op: Name, x: Constant): Constant = {op, x.tag} match { - case {nme.ZNOT, BooleanTag} => Constant(!x.booleanValue) + private def foldUnop(op: Name, x: Constant): Constant = Pair(op, x.tag) match { + case Pair(nme.ZNOT, BooleanTag) => Constant(!x.booleanValue) - case {nme.NOT , IntTag } => Constant(~x.intValue) - case {nme.NOT , LongTag } => Constant(~x.longValue) + case Pair(nme.NOT , IntTag ) => Constant(~x.intValue) + case Pair(nme.NOT , LongTag ) => Constant(~x.longValue) - case {nme.ADD , IntTag } => Constant(+x.intValue) - case {nme.ADD , LongTag } => Constant(+x.longValue) - case {nme.ADD , FloatTag } => Constant(+x.floatValue) - case {nme.ADD , DoubleTag } => Constant(+x.doubleValue) + case Pair(nme.ADD , IntTag ) => Constant(+x.intValue) + case Pair(nme.ADD , LongTag ) => Constant(+x.longValue) + case Pair(nme.ADD , FloatTag ) => Constant(+x.floatValue) + case Pair(nme.ADD , DoubleTag ) => Constant(+x.doubleValue) - case {nme.SUB , IntTag } => Constant(-x.intValue) - case {nme.SUB , LongTag } => Constant(-x.longValue) - case {nme.SUB , FloatTag } => Constant(-x.floatValue) - case {nme.SUB , DoubleTag } => Constant(-x.doubleValue) + case Pair(nme.SUB , IntTag ) => Constant(-x.intValue) + case Pair(nme.SUB , LongTag ) => Constant(-x.longValue) + case Pair(nme.SUB , FloatTag ) => Constant(-x.floatValue) + case Pair(nme.SUB , DoubleTag ) => Constant(-x.doubleValue) case _ => null } diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 72f8d8540e..0fb3d02cc5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -41,7 +41,7 @@ trait Contexts requires Analyzer { assert(pkg ne null) val qual = gen.mkAttributedStableRef(pkg) sc = sc.makeNewImport( - Import(qual, List({nme.WILDCARD, null})) + Import(qual, List(Pair(nme.WILDCARD, null))) .setSymbol(NoSymbol.newImport(NoPos).setFlag(SYNTHETIC).setInfo(ImportType(qual))) .setType(NoType)) sc.depth = sc.depth + 1 @@ -364,12 +364,12 @@ trait Contexts requires Analyzer { } def pushTypeBounds(sym: Symbol): unit = { - savedTypeBounds = {sym, sym.info} :: savedTypeBounds + savedTypeBounds = Pair(sym, sym.info) :: savedTypeBounds } def restoreTypeBounds(tp: Type): Type = { var current = tp - for (val {sym, info} <- savedTypeBounds) { + for (val Pair(sym, info) <- savedTypeBounds) { if (settings.debug.value) log("resetting " + sym + " to " + info); sym.info match { case TypeBounds(lo, hi) if (hi <:< lo && lo <:< hi) => @@ -393,8 +393,8 @@ trait Contexts requires Analyzer { val pre = imp.qual.tpe def collect(sels: List[Pair[Name, Name]]): List[ImplicitInfo] = sels match { case List() => List() - case List{nme.WILDCARD, _} => collectImplicits(pre.implicitMembers, pre) - case {from, to} :: sels1 => + case List(Pair(nme.WILDCARD, _)) => collectImplicits(pre.implicitMembers, pre) + case Pair(from, to) :: sels1 => var impls = collect(sels1) filter (info => info.name != from) if (to != nme.WILDCARD) { val sym = imp.importedSymbol(to) diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 3e63401356..91ff898450 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -50,6 +50,14 @@ trait Infer requires Analyzer { } else formals1 } + def actualTypes(actuals: List[Type], nformals: int): List[Type] = + if (nformals == 1 && actuals.length != 1) + List(if (actuals.length == 0) UnitClass.tpe else tupleType(actuals)) + else actuals + + def actualArgs(pos: PositionType, actuals: List[Tree], nformals: int): List[Tree] = + if (nformals == 1 && actuals.length != 1) List(gen.mkTuple(actuals) setPos pos) else actuals + /** A fresh type varable with given type parameter as origin. * * @param tparam ... @@ -134,7 +142,7 @@ trait Infer requires Analyzer { val bound: Type = if (up) tparam.info.bounds.hi else tparam.info.bounds.lo //Console.println("solveOne0 "+tvar+" "+config+" "+bound);//DEBUG var cyclic = false - for (val {tvar2, {tparam2, variance2}} <- config) { + for (val Pair(tvar2, Pair(tparam2, variance2)) <- config) { if (tparam2 != tparam && ((bound contains tparam2) || up && (tparam2.info.bounds.lo =:= tparam.tpe) || @@ -170,7 +178,7 @@ trait Infer requires Analyzer { assertNonCyclic(tvar)//debug } } - for (val {tvar, {tparam, variance}} <- config) + for (val Pair(tvar, Pair(tparam, variance)) <- config) solveOne(tvar, tparam, variance) tvars map instantiate } @@ -227,11 +235,11 @@ trait Infer requires Analyzer { "expression of type " + tree.tpe else if (tree.symbol.hasFlag(OVERLOADED)) "overloaded method " + tree.symbol + " with alternatives " + tree.tpe - else ( + else tree.symbol.toString() + (if (tree.tpe.paramSectionCount > 0) ": " else " of type ") + - tree.tpe - ) + tree.tpe + + (if (tree.symbol.name == nme.apply) tree.symbol.locationString else "") def applyErrorMsg(tree: Tree, msg: String, argtpes: List[Type], pt: Type) = ( treeSymTypeMsg(tree) + msg + argtpes.mkString("(", ",", ")") + @@ -295,13 +303,13 @@ trait Infer requires Analyzer { explainName(sym1) explainName(sym2) if (sym1.owner == sym2.owner) sym2.name = newTypeName("(some other)"+sym2.name) - {sym1, sym2, name} + Triple(sym1, sym2, name) } } val result = op - for (val {sym1, sym2, name} <- patches) { + for (val Triple(sym1, sym2, name) <- patches) { sym1.name = name sym2.name = name } @@ -519,10 +527,11 @@ trait Infer requires Analyzer { * @return ... */ def isApplicable(undetparams: List[Symbol], ftpe: Type, - argtpes: List[Type], pt: Type): boolean = + argtpes0: List[Type], pt: Type): boolean = ftpe match { case MethodType(formals0, restpe) => - val formals = formalTypes(formals0, argtpes.length) + val formals = formalTypes(formals0, argtpes0.length) + val argtpes = actualTypes(argtpes0, formals.length) if (undetparams.isEmpty) { (formals.length == argtpes.length && isCompatible(argtpes, formals) && @@ -539,7 +548,7 @@ trait Infer requires Analyzer { } case PolyType(tparams, restpe) => val tparams1 = cloneSymbols(tparams) - isApplicable(tparams1 ::: undetparams, restpe.substSym(tparams, tparams1), argtpes, pt) + isApplicable(tparams1 ::: undetparams, restpe.substSym(tparams, tparams1), argtpes0, pt) case ErrorType => true case _ => @@ -650,13 +659,12 @@ trait Infer requires Analyzer { */ def inferMethodInstance(fn: Tree, undetparams: List[Symbol], args: List[Tree], pt: Type): List[Symbol] = fn.tpe match { - case MethodType(formals, restpe) => + case MethodType(formals0, restpe) => try { - val argtpes = args map (.tpe.deconst) + val formals = formalTypes(formals0, args.length) + val argtpes = actualTypes(args map (.tpe.deconst), formals.length) val uninstantiated = new ListBuffer[Symbol] - val targs = methTypeArgs( - undetparams, formalTypes(formals, argtpes.length), - restpe, argtpes, pt, uninstantiated) + val targs = methTypeArgs(undetparams, formals, restpe, argtpes, pt, uninstantiated) checkBounds(fn.pos, NoPrefix, NoSymbol, undetparams, targs, "inferred ") //Console.println("UNAPPLY subst type "+undetparams+" to "+targs+" in "+fn+" ( "+args+ ")") val treeSubst = new TreeTypeSubstituter(undetparams, targs) @@ -685,8 +693,8 @@ trait Infer requires Analyzer { * any correspondiong non-variant type arguments of bt1 and bt2 are the same */ def isPopulated(tp1: Type, tp2: Type): boolean = { - def isConsistent(tp1: Type, tp2: Type): boolean = {tp1, tp2} match { - case {TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)} => + def isConsistent(tp1: Type, tp2: Type): boolean = Pair(tp1, tp2) match { + case Pair(TypeRef(pre1, sym1, args1), TypeRef(pre2, sym2, args2)) => assert(sym1 == sym2) pre1 =:= pre2 && !(List.map3(args1, args2, sym1.typeParams) { @@ -773,9 +781,9 @@ trait Infer requires Analyzer { if (settings.debug.value) log("new alias of " + tparam + " = " + tparam.info) } else { val instType = toOrigin(tvar.constr.inst) - val {loBounds, hiBounds} = - if (instType != NoType && isFullyDefined(instType)) {List(instType), List(instType)} - else {tvar.constr.lobounds, tvar.constr.hibounds} + val Pair(loBounds, hiBounds) = + if (instType != NoType && isFullyDefined(instType)) Pair(List(instType), List(instType)) + else Pair(tvar.constr.lobounds, tvar.constr.hibounds) val lo = lub(tparam.info.bounds.lo :: loBounds map toOrigin) val hi = glb(tparam.info.bounds.hi :: hiBounds map toOrigin) if (!(lo <:< hi)) { diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 162bc87d43..d7025f3dc1 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -219,7 +219,7 @@ trait Namers requires Analyzer { def skolemize(tparams: List[AbsTypeDef]): unit = { val tskolems = newTypeSkolems(tparams map (.symbol)) - for (val {tparam, tskolem} <- tparams zip tskolems) tparam.symbol = tskolem + for (val Pair(tparam, tskolem) <- tparams zip tskolems) tparam.symbol = tskolem } def applicableTypeParams(owner: Symbol): List[Symbol] = @@ -625,8 +625,8 @@ trait Namers requires Analyzer { } true } - def checkSelectors(selectors: List[{Name, Name}]): unit = selectors match { - case {from, to} :: rest => + def checkSelectors(selectors: List[Pair[Name, Name]]): unit = selectors match { + case Pair(from, to) :: rest => if (from != nme.WILDCARD && base != ErrorType) { if (base.member(from) == NoSymbol && base.member(from.toTypeName) == NoSymbol) context.error(tree.pos, from.decode + " is not a member of " + expr); @@ -687,12 +687,12 @@ trait Namers requires Analyzer { error(ntree.pos, "duplicate value for element " + name) } else { names -= sym - {sym.name, getConstant(typer.typed(rhs, EXPRmode | CONSTmode, sym.tpe.resultType))} + Pair(sym.name, getConstant(typer.typed(rhs, EXPRmode | CONSTmode, sym.tpe.resultType))) } } } for (val name <- names) { - if (!name.attributes.contains{AnnotationDefaultAttr.tpe, List(), List()}) { + if (!name.attributes.contains(Triple(AnnotationDefaultAttr.tpe, List(), List()))) { error(t.pos, "attribute " + tpt.tpe.symbol.fullNameString + " is missing element " + name.name) } } @@ -784,8 +784,8 @@ trait Namers requires Analyzer { else if (isFunctionType(tp) && (!isFunctionType(elemtp) || tp.typeArgs.length > elemtp.typeArgs.length)) result = true - else {tp, elemtp} match { - case {TypeRef(pre, sym, args), TypeRef(elempre, elemsym, elemargs)} => + else Pair(tp, elemtp) match { + case Pair(TypeRef(pre, sym, args), TypeRef(elempre, elemsym, elemargs)) => if ((sym == elemsym) && (pre =:= elempre) && (args.length == elemargs.length)) result = List.forall2(elemargs, args) (isContainedIn) case _ => diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 0c1df47925..2afb6dd493 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -100,12 +100,12 @@ abstract class RefChecks extends InfoTransform { else ""))) } - def overridesType(tp1: Type, tp2: Type): boolean = {tp1, tp2} match { - case {MethodType(List(), rtp1), PolyType(List(), rtp2)} => + def overridesType(tp1: Type, tp2: Type): boolean = Pair(tp1, tp2) match { + case Pair(MethodType(List(), rtp1), PolyType(List(), rtp2)) => rtp1 <:< rtp2 - case {PolyType(List(), rtp1), MethodType(List(), rtp2)} => + case Pair(PolyType(List(), rtp1), MethodType(List(), rtp2)) => rtp1 <:< rtp2 - case {TypeRef(_, sym, _), _} if (sym.isModuleClass) => + case Pair(TypeRef(_, sym, _), _) if (sym.isModuleClass) => overridesType(PolyType(List(), tp1), tp2) case _ => tp1 <:< tp2 @@ -375,7 +375,7 @@ abstract class RefChecks extends InfoTransform { def validateVarianceArgs(tps: List[Type], variance: int, tparams: List[Symbol]): unit = (tps zip tparams) foreach { - case {tp, tparam} => validateVariance(tp, variance * tparam.variance) + case Pair(tp, tparam) => validateVariance(tp, variance * tparam.variance) } validateVariance(all, variance) diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 84eb0cc9bf..51ed171076 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -36,7 +36,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT class SuperAccTransformer(unit: CompilationUnit) extends TypingTransformer(unit) { private var validCurrentOwner = true - private var accDefs: List[{Symbol, ListBuffer[Tree]}] = List() + private var accDefs: List[Pair[Symbol, ListBuffer[Tree]]] = List() private def accDefBuf(clazz: Symbol) = accDefs.dropWhile(._1.!=(clazz)).head._2 @@ -63,7 +63,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT super.transform(tree) case Template(parents, body) => val ownAccDefs = new ListBuffer[Tree]; - accDefs = {currentOwner, ownAccDefs} :: accDefs; + accDefs = Pair(currentOwner, ownAccDefs) :: accDefs; // ugly hack... normally, the following line should not be // necessary, the 'super' method taking care of that. but because diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index f5999b3582..bd534813c2 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -81,7 +81,7 @@ trait SyntheticMethods requires Analyzer { //val retTpe = lub(accs map (.tpe.resultType)) val method = syntheticMethod(nme.element, FINAL, MethodType(List(IntClass.tpe), AnyClass.tpe/*retTpe*/)) typed(DefDef(method, vparamss => Match(Ident(vparamss.head.head), { - (for(val {sym,i} <- accs.zipWithIndex) yield { + (for(val Pair(sym,i) <- accs.zipWithIndex) yield { CaseDef(Literal(Constant(i)),EmptyTree, Ident(sym)) }):::List(CaseDef(Ident(nme.WILDCARD), EmptyTree, Throw(New(TypeTree(IndexOutOfBoundsExceptionClass.tpe), List(List( diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index b546d4b8d6..1e645f3baa 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -974,21 +974,21 @@ trait Typers requires Analyzer { */ def computeParamAliases(clazz: Symbol, vparamss: List[List[ValDef]], rhs: Tree): unit = { if (settings.debug.value) log("computing param aliases for "+clazz+":"+clazz.primaryConstructor.tpe+":"+rhs);//debug - def decompose(call: Tree): {Tree, List[Tree]} = call match { + def decompose(call: Tree): Pair[Tree, List[Tree]] = call match { case Apply(fn, args) => - val {superConstr, args1} = decompose(fn) + val Pair(superConstr, args1) = decompose(fn) val formals = fn.tpe.paramTypes val args2 = if (formals.isEmpty || formals.last.symbol != RepeatedParamClass) args else args.take(formals.length - 1) ::: List(EmptyTree) if (args2.length != formals.length) assert(false, "mismatch " + clazz + " " + formals + " " + args2);//debug - {superConstr, args1 ::: args2} + Pair(superConstr, args1 ::: args2) case Block(stats, expr) => decompose(stats.head) case _ => - {call, List()} + Pair(call, List()) } - val {superConstr, superArgs} = decompose(rhs) + val Pair(superConstr, superArgs) = decompose(rhs) assert(superConstr.symbol ne null)//debug if (superConstr.symbol.isPrimaryConstructor) { val superClazz = superConstr.symbol.owner @@ -1221,16 +1221,16 @@ trait Typers requires Analyzer { def typedFunction(fun: Function, mode: int, pt: Type): Tree = { val codeExpected = !forCLDC && !forMSIL && (pt.symbol isNonBottomSubClass CodeClass) - def decompose(pt: Type): {Symbol, List[Type], Type} = + def decompose(pt: Type): Triple[Symbol, List[Type], Type] = if (isFunctionType(pt) || pt.symbol == PartialFunctionClass && fun.vparams.length == 1 && fun.body.isInstanceOf[Match]) - {pt.symbol, pt.typeArgs.init, pt.typeArgs.last} + Triple(pt.symbol, pt.typeArgs.init, pt.typeArgs.last) else - {FunctionClass(fun.vparams.length), fun.vparams map (x => NoType), WildcardType} + Triple(FunctionClass(fun.vparams.length), fun.vparams map (x => NoType), WildcardType) - val {clazz, argpts, respt} = decompose(if (codeExpected) pt.typeArgs.head else pt) + val Triple(clazz, argpts, respt) = decompose(if (codeExpected) pt.typeArgs.head else pt) if (fun.vparams.length != argpts.length) errorTree(fun, "wrong number of parameters; expected = " + argpts.length) @@ -1381,14 +1381,15 @@ trait Typers requires Analyzer { typedApply(tree, adapt(fun, funMode(mode), WildcardType), args1, mode, pt) case MethodType(formals0, restpe) => val formals = formalTypes(formals0, args.length) - if (formals.length != args.length) { - //Console.println(formals.length+" "+args.length);//DEBUG + var args1 = actualArgs(tree.pos, args, formals.length) + if (formals.length != args1.length) { + Console.println(formals+" "+args1);//DEBUG errorTree(tree, "wrong number of arguments for "+treeSymTypeMsg(fun)) } else { val tparams = context.undetparams context.undetparams = List() if (tparams.isEmpty) { - val args1 = typedArgs(args, mode, formals0, formals) + val args2 = typedArgs(args1, mode, formals0, formals) def ifPatternSkipFormals(tp: Type) = tp match { case MethodType(_, rtp) if ((mode & PATTERNmode) != 0) => rtp case _ => tp @@ -1408,7 +1409,7 @@ trait Typers requires Analyzer { // the compiler thinks, the PLUS method takes only one argument, // but he thinks it's an instance method -> still two ref's on the stack // -> translated by backend - val rhs = copy.Apply(tree, f, args) + val rhs = copy.Apply(tree, f, args1) return typed(Assign(qual, rhs)) } case _ => () @@ -1418,9 +1419,9 @@ trait Typers requires Analyzer { if (fun.symbol == List_apply && args.isEmpty) { atPos(tree.pos) { gen.mkNil setType restpe } } else if ((mode & CONSTmode) != 0 && fun.symbol.owner == PredefModule.tpe.symbol && fun.symbol.name == nme.Array) { - val elems = new Array[Constant](args1.length) + val elems = new Array[Constant](args2.length) var i = 0; - for (val arg <- args1) arg match { + for (val arg <- args2) arg match { case Literal(value) => elems(i) = value i = i + 1 @@ -1430,7 +1431,7 @@ trait Typers requires Analyzer { Literal(arrayConst) setType mkConstantType(arrayConst) } else - constfold(copy.Apply(tree, fun, args1).setType(ifPatternSkipFormals(restpe))) + constfold(copy.Apply(tree, fun, args2).setType(ifPatternSkipFormals(restpe))) } else { assert((mode & PATTERNmode) == 0); // this case cannot arise for patterns val lenientTargs = protoTypeArgs(tparams, formals, restpe, pt) @@ -1447,12 +1448,12 @@ trait Typers requires Analyzer { } arg1 } - val args1 = List.map2(args, formals)(typedArgToPoly) - if (args1 exists (.tpe.isError)) setError(tree) + val args2 = List.map2(args1, formals)(typedArgToPoly) + if (args2 exists (.tpe.isError)) setError(tree) else { - if (settings.debug.value) log("infer method inst "+fun+", tparams = "+tparams+", args = "+args1.map(.tpe)+", pt = "+pt+", lobounds = "+tparams.map(.tpe.bounds.lo)+", parambounds = "+tparams.map(.info));//debug - val undetparams = inferMethodInstance(fun, tparams, args1, pt) - val result = typedApply(tree, fun, args1, mode, pt) + if (settings.debug.value) log("infer method inst "+fun+", tparams = "+tparams+", args = "+args2.map(.tpe)+", pt = "+pt+", lobounds = "+tparams.map(.tpe.bounds.lo)+", parambounds = "+tparams.map(.info));//debug + val undetparams = inferMethodInstance(fun, tparams, args2, pt) + val result = typedApply(tree, fun, args2, mode, pt) context.undetparams = undetparams result } @@ -1499,14 +1500,14 @@ trait Typers requires Analyzer { val oldArgType = arg.tpe if (!isApplicable(List(), unappType, List(arg.tpe), WildcardType)) { //Console.println("UNAPP: need to typetest, arg.tpe = "+arg.tpe+", unappType = "+unappType) - def freshArgType(tp: Type): {Type, List[Symbol]} = tp match { + def freshArgType(tp: Type): Pair[Type, List[Symbol]] = tp match { case MethodType(formals, restpe) => - {formals(0), List()} + Pair(formals(0), List()) case PolyType(tparams, restype) => val tparams1 = cloneSymbols(tparams) - {freshArgType(restype)._1.substSym(tparams, tparams1), tparams1} + Pair(freshArgType(restype)._1.substSym(tparams, tparams1), tparams1) } - val {unappFormal, freeVars} = freshArgType(unappType) + val Pair(unappFormal, freeVars) = freshArgType(unappType) val context1 = context.makeNewScope(context.tree, context.owner) freeVars foreach context1.scope.enter val typer1 = new Typer(context1) @@ -1567,12 +1568,12 @@ trait Typers requires Analyzer { error(ntree.pos, "duplicate value for element " + name) } else { names -= sym - {sym.name, getConstant(typed(rhs, EXPRmode | CONSTmode, sym.tpe.resultType))} + Pair(sym.name, getConstant(typed(rhs, EXPRmode | CONSTmode, sym.tpe.resultType))) } } } for (val name <- names) { - if (!name.attributes.contains{AnnotationDefaultAttr.tpe, List(), List()}) { + if (!name.attributes.contains(Triple(AnnotationDefaultAttr.tpe, List(), List()))) { error(constr.pos, "attribute " + tpt.tpe.symbol.fullNameString + " is missing element " + name.name) } } @@ -2151,6 +2152,7 @@ trait Typers requires Analyzer { } case Typed(expr, tpt @ Ident(name)) if (name == nme.WILDCARD_STAR.toTypeName) => + //todo: do this: errorTree(tree, "`: _*' annotation only legal for method arguments") val expr1 = typed(expr, mode & stickyModes, seqType(pt)) expr1.tpe.baseType(SeqClass) match { case TypeRef(_, _, List(elemtp)) => @@ -2198,12 +2200,12 @@ trait Typers requires Analyzer { } case Super(qual, mix) => - val {clazz, selftype} = + val Pair(clazz, selftype) = if (tree.symbol != NoSymbol) { - {tree.symbol, tree.symbol.thisType} + Pair(tree.symbol, tree.symbol.thisType) } else { val clazzContext = qualifyingClassContext(tree, qual) - {clazzContext.owner, clazzContext.prefix} + Pair(clazzContext.owner, clazzContext.prefix) } if (clazz == NoSymbol) setError(tree) else { @@ -2229,12 +2231,12 @@ trait Typers requires Analyzer { } case This(qual) => - val {clazz, selftype} = + val Pair(clazz, selftype) = if (tree.symbol != NoSymbol) { - {tree.symbol, tree.symbol.thisType} + Pair(tree.symbol, tree.symbol.thisType) } else { val clazzContext = qualifyingClassContext(tree, qual) - {clazzContext.owner, clazzContext.prefix} + Pair(clazzContext.owner, clazzContext.prefix) } if (clazz == NoSymbol) setError(tree) else { diff --git a/src/library/scala/BigInt.scala b/src/library/scala/BigInt.scala index 4fcbfd82ce..9be8a45dbd 100644 --- a/src/library/scala/BigInt.scala +++ b/src/library/scala/BigInt.scala @@ -175,9 +175,9 @@ class BigInt(val bigInteger: BigInteger) extends runtime.BoxedNumber { /** Returns a pair of two BigInts containing (this / that) and (this % that). */ - def /% (that: BigInt): {BigInt, BigInt} = { + def /% (that: BigInt): Pair[BigInt, BigInt] = { val dr = this.bigInteger.divideAndRemainder(that.bigInteger) - {new BigInt(dr(0)), new BigInt(dr(1))} + Pair(new BigInt(dr(0)), new BigInt(dr(1))) } /** Leftshift of BigInt diff --git a/src/library/scala/Console.scala b/src/library/scala/Console.scala index 488e091390..ea2968fc03 100644 --- a/src/library/scala/Console.scala +++ b/src/library/scala/Console.scala @@ -272,9 +272,9 @@ object Console { * @param format ... * @return ... */ - def readf2(format: String): {Any, Any} = { + def readf2(format: String): Pair[Any, Any] = { val res = readf(format) - {res.head, res.tail.head} + Pair(res.head, res.tail.head) } /** Read in some structured input, specified by a format specifier. @@ -287,7 +287,7 @@ object Console { */ def readf3(format: String): Triple[Any, Any, Any] = { val res = readf(format) - {res.head, res.tail.head, res.tail.tail.head} + Triple(res.head, res.tail.head, res.tail.tail.head) } private def textComponents(a: Array[AnyRef]): List[Any] = { diff --git a/src/library/scala/Iterator.scala b/src/library/scala/Iterator.scala index 528fd68635..00e40ab5b9 100644 --- a/src/library/scala/Iterator.scala +++ b/src/library/scala/Iterator.scala @@ -348,9 +348,9 @@ trait Iterator[+A] { * and bi are the elements from iterator * that. */ - def zip[B](that: Iterator[B]) = new Iterator[{A, B}] { + def zip[B](that: Iterator[B]) = new Iterator[Pair[A, B]] { def hasNext = Iterator.this.hasNext && that.hasNext - def next = {Iterator.this.next, that.next} + def next = Pair(Iterator.this.next, that.next) } /** Return an iterator that pairs each element of this iterator @@ -361,11 +361,11 @@ trait Iterator[+A] { * {a1,1}... where ai * are the elements from this iterator. */ - def zipWithIndex = new Iterator[{A, int}] { + def zipWithIndex = new Iterator[Pair[A, int]] { var idx = 0 def hasNext = Iterator.this.hasNext def next = { - val ret = {Iterator.this.next, idx} + val ret = Pair(Iterator.this.next, idx) idx = idx + 1 ret } @@ -541,7 +541,7 @@ trait Iterator[+A] { * * @return a pair of iterators */ - def duplicate: {Iterator[A], Iterator[A]} = { + def duplicate: Pair[Iterator[A], Iterator[A]] = { var xs: List[A] = Nil var ahead: Iterator[A] = null class Partner extends Iterator[A] { @@ -571,7 +571,7 @@ trait Iterator[+A] { } } ahead = new Partner - {ahead, new Partner} + Pair(ahead, new Partner) } /** Fills the given array xs with the elements of diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala index 25b7032ca9..4e01ee2107 100644 --- a/src/library/scala/List.scala +++ b/src/library/scala/List.scala @@ -140,7 +140,7 @@ object List { * @param xs the list of pairs to unzip * @return a pair of lists: the first list in the pair contains the list */ - def unzip[a,b](xs: List[{a,b}]): {List[a], List[b]} = { + def unzip[a,b](xs: List[Pair[a,b]]): Pair[List[a], List[b]] = { val b1 = new ListBuffer[a] val b2 = new ListBuffer[b] var xc = xs @@ -149,7 +149,7 @@ object List { b2 += xc.head._2 xc = xc.tail } - {b1.toList, b2.toList} + Pair(b1.toList, b2.toList) } /** Converts an iterator to a list @@ -590,7 +590,7 @@ sealed abstract class List[+a] extends Seq[a] { * @return a pair of lists composed of the first n * elements, and the other elements. */ - def splitAt(n: Int): {List[a], List[a]} = { + def splitAt(n: Int): Pair[List[a], List[a]] = { val b = new ListBuffer[a] var i = 0 var these = this @@ -599,7 +599,7 @@ sealed abstract class List[+a] extends Seq[a] { b += these.head these = these.tail } - {b.toList, these} + Pair(b.toList, these) } /** Returns the longest prefix of this list whose elements satisfy @@ -637,19 +637,19 @@ sealed abstract class List[+a] extends Seq[a] { * @return a pair consisting of the longest prefix of the list whose * elements all satisfy p, and the rest of the list. */ - def span(p: a => Boolean): {List[a], List[a]} = { + def span(p: a => Boolean): Pair[List[a], List[a]] = { val b = new ListBuffer[a] var these = this while (!these.isEmpty && p(these.head)) { b += these.head these = these.tail } - {b.toList, these} + Pair(b.toList, these) } /** Like span but with the predicate inverted. */ - def break(p: a => Boolean): {List[a], List[a]} = span { x => !p(x) } + def break(p: a => Boolean): Pair[List[a], List[a]] = span { x => !p(x) } /** Returns the n-th element of this list. The first element * (head of the list) is at position 0. @@ -752,7 +752,7 @@ sealed abstract class List[+a] extends Seq[a] { * The relative order of the elements in the sub-lists is the * same as in the original list. */ - def partition(p: a => Boolean): {List[a], List[a]} = { + def partition(p: a => Boolean): Pair[List[a], List[a]] = { val btrue = new ListBuffer[a] val bfalse = new ListBuffer[a] var these = this @@ -760,7 +760,7 @@ sealed abstract class List[+a] extends Seq[a] { (if (p(these.head)) btrue else bfalse) += these.head these = these.tail } - {btrue.toList, bfalse.toList} + Pair(btrue.toList, bfalse.toList) } /**

@@ -804,7 +804,7 @@ sealed abstract class List[+a] extends Seq[a] { else y::z::x::acc case hd1::hd2::hd3::tail => { val List(x, y, z) = sort_1(hd1::hd2::hd3::Nil, Nil) - val {small, large} = tail.partition((e2) => lt(e2, y)) + val Pair(small, large) = tail.partition((e2) => lt(e2, y)) sort_1(x::small, y::sort_1(z::large, acc)) } } @@ -828,7 +828,7 @@ sealed abstract class List[+a] extends Seq[a] { else y::z::x::Nil case hd1::hd2::hd3::tail => { val List(x, y, z) = sort_1(hd1::hd2::hd3::Nil, Nil) - val {small,large} = tail.partition((e2) => lt(e2, y)) + val Pair(small,large) = tail.partition((e2) => lt(e2, y)) sort_1(x::small, y::sort_1(z::large, Nil)); } } @@ -999,12 +999,12 @@ sealed abstract class List[+a] extends Seq[a] { * List(a0, ..., am) * zip List(b0, ..., bn) is invoked. */ - def zip[b](that: List[b]): List[{a,b}] = { - val b = new ListBuffer[{a, b}] + def zip[b](that: List[b]): List[Pair[a,b]] = { + val b = new ListBuffer[Pair[a, b]] var these = this var those = that while (!these.isEmpty && !those.isEmpty) { - b += {these.head, those.head} + b += Pair(these.head, those.head) these = these.tail those = those.tail } @@ -1018,12 +1018,12 @@ sealed abstract class List[+a] extends Seq[a] { * where ai are the elements of this list. */ def zipWithIndex = { - val b = new ListBuffer[{a,int}] + val b = new ListBuffer[Pair[a,int]] var these = this var idx = 0 while(!these.isEmpty) { - b += {these.head, idx} + b += Pair(these.head, idx) these = these.tail idx = idx + 1 } @@ -1050,21 +1050,21 @@ sealed abstract class List[+a] extends Seq[a] { * [b0, ..., bm] is * invoked where m > n. */ - def zipAll[b, c >: a, d >: b](that: List[b], thisElem: c, thatElem: d): List[{c,d}] = { - val b = new ListBuffer[{c, d}] + def zipAll[b, c >: a, d >: b](that: List[b], thisElem: c, thatElem: d): List[Pair[c,d]] = { + val b = new ListBuffer[Pair[c, d]] var these = this var those = that while (!these.isEmpty && !those.isEmpty) { - b += {these.head, those.head} + b += Pair(these.head, those.head) these = these.tail those = those.tail } while (!these.isEmpty) { - b += {these.head, thatElem} + b += Pair(these.head, thatElem) these = these.tail } while (!those.isEmpty) { - b += {thisElem, those.head} + Pair(thisElem, those.head) those = those.tail } b.toList diff --git a/src/library/scala/Stream.scala b/src/library/scala/Stream.scala index db02cd89d8..fe140f2598 100644 --- a/src/library/scala/Stream.scala +++ b/src/library/scala/Stream.scala @@ -13,7 +13,7 @@ package scala import compat.StringBuilder -import Predef.{NoSuchElementException, UnsupportedOperationException} +import Predef.{NoSuchElementException, UnsupportedOperationException,Pair} /** * The object Stream provides helper functions @@ -53,11 +53,11 @@ object Stream { } } - def unapply[a](str: Stream[a]): Option[{a,Stream[a]}] = + def unapply[a](str: Stream[a]): Option[Pair[a,Stream[a]]] = if(str.isEmpty) None else - Some{str.head, str.tail} + Some(Pair(str.head, str.tail)) } /** A stream containing all elements of a given iterator, in the order they are produced. diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala index 45f45a110b..c02c195086 100644 --- a/src/library/scala/collection/Map.scala +++ b/src/library/scala/collection/Map.scala @@ -35,7 +35,7 @@ import Predef._ * @author Martin Odersky * @version 1.2, 31/12/2006 */ -trait Map[A, +B] extends PartialFunction[A, B] with Iterable[{A, B}] { +trait Map[A, +B] extends PartialFunction[A, B] with Iterable[Pair[A, B]] { /** Compute the number of key-to-value mappings. * @@ -125,7 +125,7 @@ trait Map[A, +B] extends PartialFunction[A, B] with Iterable[{A, B}] { override def equals(that: Any): Boolean = that match { case other: Map[a, b] => this.size == other.size && this.elements.forall { - case {key, value} => other.get(key.asInstanceOf[a]) match { + case Pair(key, value) => other.get(key.asInstanceOf[a]) match { case None => false case Some(otherval) => value == otherval } diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala index 142d2c5ba0..2585f24c7d 100644 --- a/src/library/scala/collection/MapProxy.scala +++ b/src/library/scala/collection/MapProxy.scala @@ -20,7 +20,7 @@ package scala.collection * @author Matthias Zenger * @version 1.0, 21/07/2003 */ -trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[{A, B}] { +trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[Pair[A, B]] { def self: Map[A, B] diff --git a/src/library/scala/collection/immutable/EmptyMap.scala b/src/library/scala/collection/immutable/EmptyMap.scala index fbf8c10c1a..127781f2d5 100755 --- a/src/library/scala/collection/immutable/EmptyMap.scala +++ b/src/library/scala/collection/immutable/EmptyMap.scala @@ -12,6 +12,8 @@ package scala.collection.immutable +import Predef.Pair + /** This class implements empty immutable maps * @author Martin Oderskty * @version 1.0, 019/01/2007 @@ -23,7 +25,7 @@ class EmptyMap[A, +B] extends Map[A, B] { def get(key: A): Option[B] = None - def elements: Iterator[{A, B}] = Iterator.empty + def elements: Iterator[Pair[A, B]] = Iterator.empty def empty[C]: Map[A, C] = new EmptyMap[A, C] diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala index 3cda6cf08b..57fc4b8ed9 100755 --- a/src/library/scala/collection/immutable/HashMap.scala +++ b/src/library/scala/collection/immutable/HashMap.scala @@ -25,7 +25,7 @@ object HashMap { /** The canonical factory for this type */ - def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems } [serializable] @@ -92,7 +92,7 @@ class HashMap[A, B] extends Map[A,B] with mutable.HashTable[A] { def elements = { makeCopyIfUpdated() - entries map {e => {e.key, getValue(e)}} + entries map {e => Pair(e.key, getValue(e))} } private def getValue(e: Entry) = diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala index 4ce9c4cc39..c3fdfe1a80 100644 --- a/src/library/scala/collection/immutable/ListMap.scala +++ b/src/library/scala/collection/immutable/ListMap.scala @@ -24,7 +24,7 @@ object ListMap { /** The canonical factory for this type */ - def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems } /** This class implements immutable maps using a list-based data @@ -79,13 +79,13 @@ class ListMap[A, +B] extends Map[A, B] { /** Returns an iterator over key-value pairs. */ - def elements: Iterator[{A,B}] = - new Iterator[{A,B}] { + def elements: Iterator[Pair[A,B]] = + new Iterator[Pair[A,B]] { var self: ListMap[A,B] = ListMap.this def hasNext = !self.isEmpty - def next: {A,B} = + def next: Pair[A,B] = if (!hasNext) throw new NoSuchElementException("next on empty iterator") - else { val res = {self.key, self.value}; self = self.next; res } + else { val res = Pair(self.key, self.value); self = self.next; res } }.toList.reverse.elements protected def key: A = throw new NoSuchElementException("empty map") diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala index 5cc326c031..108cb07f44 100644 --- a/src/library/scala/collection/immutable/Map.scala +++ b/src/library/scala/collection/immutable/Map.scala @@ -41,7 +41,7 @@ object Map { /** The canonical factory for this type */ - def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems } trait Map[A, +B] extends collection.Map[A, B] { @@ -68,7 +68,7 @@ trait Map[A, +B] extends collection.Map[A, B] { * @param kv the key/value pair. * @return A new map with the new binding added to this map */ - def + [B1 >: B] (kv: {A, B1}): Map[A, B1] = update(kv._1, kv._2) + def + [B1 >: B] (kv: Pair[A, B1]): Map[A, B1] = update(kv._1, kv._2) /** Add two or more key/value pairs to this map. * @param kv1 the first key/value pair. @@ -76,21 +76,21 @@ trait Map[A, +B] extends collection.Map[A, B] { * @param kvs the remaining key/value pairs. * @return A new map with the new bindings added */ - def + [B1 >: B] (kv1: {A, B1}, kv2: {A, B1}, kvs: {A, B1}*): Map[A, B1] = + def + [B1 >: B] (kv1: Pair[A, B1], kv2: Pair[A, B1], kvs: Pair[A, B1]*): Map[A, B1] = this + kv1 + kv2 ++ kvs /** Add a sequence of key/value pairs to this map. * @param kvs the iterable object containing all key/value pairs. * @return A new map with the new bindings added */ - def ++ [B1 >: B] (kvs: Iterable[{A, B1}]): Map[A, B1] = + def ++ [B1 >: B] (kvs: Iterable[Pair[A, B1]]): Map[A, B1] = ((this: Map[A, B1]) /: kvs) ((m, kv) => m + kv) /** Add a sequence of key/value pairs to this map. * @param kvs the iterator containing all key/value pairs. * @return A new map with the new bindings added */ - def ++ [B1 >: B] (kvs: Iterator[{A, B1}]): Map[A, B1] = + def ++ [B1 >: B] (kvs: Iterator[Pair[A, B1]]): Map[A, B1] = ((this: Map[A, B1]) /: kvs) ((m, kv) => m + kv) /** Remove a key from this map @@ -140,7 +140,7 @@ trait Map[A, +B] extends collection.Map[A, B] { */ def transform[C](f: (A, B) => C): Map[A, C] = { var res = empty[C] - foreach { case {key, value} => res = res.update(key, f(key, value)) } + foreach { case Pair(key, value) => res = res.update(key, f(key, value)) } res } @@ -150,10 +150,10 @@ trait Map[A, +B] extends collection.Map[A, B] { * @param p A prediacte over key-value pairs * @return the updated map */ - override def filter(p: {A, B} => Boolean): Map[A, B] = { + override def filter(p: Pair[A, B] => Boolean): Map[A, B] = { var res = this foreach { - case kv @ {key, _} => if (!p(kv)) { res = res - key } + case kv @ Pair(key, _) => if (!p(kv)) { res = res - key } } res } @@ -178,7 +178,7 @@ trait Map[A, +B] extends collection.Map[A, B] { * @return ... * @deprecated use + instead */ - [deprecated] def incl[B1 >: B](mappings: {A, B1}*): Map[A, B1] = incl(mappings) + [deprecated] def incl[B1 >: B](mappings: Pair[A, B1]*): Map[A, B1] = incl(mappings) /** incl can be used to add many mappings at the same time * to the map. The method assumes that each mapping is represented @@ -187,11 +187,11 @@ trait Map[A, +B] extends collection.Map[A, B] { * * @deprecated use ++ instead */ - [deprecated] def incl[B1 >: B](map: Iterable[{A, B1}]): Map[A, B1] = { + [deprecated] def incl[B1 >: B](map: Iterable[Pair[A, B1]]): Map[A, B1] = { val iter = map.elements var res: Map[A, B1] = this while (iter.hasNext) { - val {key, value} = iter.next + val Pair(key, value) = iter.next res = res.update(key, value) } res @@ -227,7 +227,7 @@ trait Map[A, +B] extends collection.Map[A, B] { * @param p ... * @return the string representation of a map entry */ - [deprecated] def mappingToString[B1 >: B](p: {A, B1}) = p._1.toString() + " -> " + p._2 + [deprecated] def mappingToString[B1 >: B](p: Pair[A, B1]) = p._1.toString() + " -> " + p._2 /** @deprecated use +({A, B}) instead */ diff --git a/src/library/scala/collection/immutable/Map1.scala b/src/library/scala/collection/immutable/Map1.scala index 22a2e05b09..edd8dc11fc 100755 --- a/src/library/scala/collection/immutable/Map1.scala +++ b/src/library/scala/collection/immutable/Map1.scala @@ -12,6 +12,8 @@ package scala.collection.immutable +import Predef.Pair + /** This class implements empty immutable maps * @author Martin Oderskty * @version 1.0, 019/01/2007 @@ -24,7 +26,7 @@ class Map1[A, +B](key1: A, value1: B) extends Map[A, B] { def get(key: A): Option[B] = if (key == key1) Some(value1) else None - def elements = Iterator.single({key1, value1}) + def elements = Iterator.single(Pair(key1, value1)) def empty[B]: Map[A, B] = new EmptyMap[A, B] diff --git a/src/library/scala/collection/immutable/Map2.scala b/src/library/scala/collection/immutable/Map2.scala index fbadfaa68d..02d4651d03 100755 --- a/src/library/scala/collection/immutable/Map2.scala +++ b/src/library/scala/collection/immutable/Map2.scala @@ -12,6 +12,8 @@ package scala.collection.immutable +import Predef.Pair + /** This class implements empty immutable maps * @author Martin Oderskty * @version 1.0, 019/01/2007 @@ -27,7 +29,7 @@ class Map2[A, +B](key1: A, value1: B, key2: A, value2: B) extends Map[A, B] { else None def elements = Iterator.fromValues( - {key1, value1}, {key2, value2}) + Pair(key1, value1), Pair(key2, value2)) def empty[C]: Map[A, C] = new EmptyMap[A, C] diff --git a/src/library/scala/collection/immutable/Map3.scala b/src/library/scala/collection/immutable/Map3.scala index 38198bbc71..b7c4a506f8 100755 --- a/src/library/scala/collection/immutable/Map3.scala +++ b/src/library/scala/collection/immutable/Map3.scala @@ -12,6 +12,8 @@ package scala.collection.immutable +import Predef.Pair + /** This class implements empty immutable maps * @author Martin Oderskty * @version 1.0, 019/01/2007 @@ -28,7 +30,7 @@ class Map3[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B) ex else None def elements = Iterator.fromValues( - {key1, value1}, {key2, value2}, {key3, value3}) + Pair(key1, value1), Pair(key2, value2), Pair(key3, value3)) def empty[C]: Map[A, C] = new EmptyMap[A, C] diff --git a/src/library/scala/collection/immutable/Map4.scala b/src/library/scala/collection/immutable/Map4.scala index 3596008109..1582123c18 100755 --- a/src/library/scala/collection/immutable/Map4.scala +++ b/src/library/scala/collection/immutable/Map4.scala @@ -29,7 +29,7 @@ class Map4[A, +B](key1: A, value1: B, key2: A, value2: B, key3: A, value3: B, ke else None def elements = Iterator.fromValues( - {key1, value1}, {key2, value2}, {key3, value3}, {key4, value4}) + Pair(key1, value1), Pair(key2, value2), Pair(key3, value3), Pair(key4, value4)) def empty[C]: Map[A, C] = new EmptyMap[A, C] diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index c88bbbdb27..c40777b417 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -100,12 +100,12 @@ class Queue[+A](elem: A*) extends Seq[A] { * @throws Predef.NoSuchElementException * @return the first element of the queue. */ - def dequeue: {A, Queue[A]} = { - val {newOut, newIn} = - if (out.isEmpty) {in.reverse, Nil} - else {out, in}; + def dequeue: Pair[A, Queue[A]] = { + val Pair(newOut, newIn) = + if (out.isEmpty) Pair(in.reverse, Nil) + else Pair(out, in) if (newOut.isEmpty) throw new NoSuchElementException("queue empty") - else {newOut.head, mkQueue(newIn, newOut.tail)} + else Pair(newOut.head, mkQueue(newIn, newOut.tail)) } /** Returns the first element in the queue, or throws an error if there @@ -155,7 +155,7 @@ class Queue[+A](elem: A*) extends Seq[A] { override def hashCode(): Int = if (isEmpty) 0 else { - val q: {A,Queue[A]} = dequeue; + val q: Pair[A,Queue[A]] = dequeue; q._1.hashCode() + q._2.hashCode() } } diff --git a/src/library/scala/collection/immutable/RedBlack.scala b/src/library/scala/collection/immutable/RedBlack.scala index cd0fd432f9..dd3c7ebc94 100755 --- a/src/library/scala/collection/immutable/RedBlack.scala +++ b/src/library/scala/collection/immutable/RedBlack.scala @@ -19,7 +19,7 @@ abstract class RedBlack[A] { def lookup(x: A): Tree[B] def update[B1 >: B](k: A, v: B1): Tree[B1] = blacken(upd(k, v)) def delete(k: A): Tree[B] = del(k) - def elements: Iterator[{A, B}] + def elements: Iterator[Pair[A, B]] def upd[B1 >: B](k: A, v: B1): Tree[B1] def del(k: A): Tree[B] def smallest: NonEmpty[B] @@ -67,8 +67,8 @@ abstract class RedBlack[A] { } } def smallest: NonEmpty[B] = if (left.isEmpty) this else left.smallest - def elements: Iterator[{A, B}] = - left.elements append Iterator.single({key, value}) append right.elements + def elements: Iterator[Pair[A, B]] = + left.elements append Iterator.single(Pair(key, value)) append right.elements } [serializable] case object Empty extends Tree[Nothing] { @@ -78,7 +78,7 @@ abstract class RedBlack[A] { def upd[B](k: A, v: B): Tree[B] = RedTree(k, v, Empty, Empty) def del(k: A): Tree[Nothing] = this def smallest: NonEmpty[Nothing] = throw new NoSuchElementException("empty map") - def elements: Iterator[{A, Nothing}] = Iterator.empty + def elements: Iterator[Pair[A, Nothing]] = Iterator.empty } [serializable] case class RedTree[+B](override val key: A, diff --git a/src/library/scala/collection/immutable/Tree.scala b/src/library/scala/collection/immutable/Tree.scala index bc69b7c4db..eef8842e39 100644 --- a/src/library/scala/collection/immutable/Tree.scala +++ b/src/library/scala/collection/immutable/Tree.scala @@ -235,7 +235,7 @@ private case class INode[A <% Ordered[A],B](t1: GBTree[A,B], def insertRight(key: A, value: B, smaller: GBTree[A,B]) = balance_p(GBNode(key, value, smaller, t1),smaller); protected def balance_p(t:GBTree[A,B],subtree:GBTree[A,B]):InsertTree[A,B] = { - val {subHeight, subSize} = subtree.count + val Pair(subHeight, subSize) = subtree.count val totalHeight = 2 * compat.Math.max(height, subHeight) val totalSize = size + subSize + 1 val BalanceHeight = totalSize * totalSize @@ -260,13 +260,13 @@ protected abstract class GBTree[A <% Ordered[A],B] extends AnyRef { /** Calculates 2^h, and size, where h is the height of the tree * and size is the number of nodes in the tree. */ - def count: {Int,Int} + def count: Pair[Int,Int] def isDefinedAt(Key: A): Boolean def get(key: A): Option[B] def apply(key: A): B def update(key: A, value: B): aNode def insert(key: A, value: B, size: Int): anInsertTree - def toList(acc: List[{A,B}]): List[{A,B}] + def toList(acc: List[Pair[A,B]]): List[Pair[A,B]] def mk_iter(iter_tail: List[aNode]): List[aNode] def delete(key: A): aNode def merge(t: aNode): aNode @@ -275,7 +275,7 @@ protected abstract class GBTree[A <% Ordered[A],B] extends AnyRef { } private case class GBLeaf[A <% Ordered[A],B]() extends GBTree[A,B] { - def count = {1, 0} + def count = Pair(1, 0) def isDefinedAt(key: A) = false def get(_key: A) = None def apply(key: A) = throw new NoSuchElementException("key " + key + " not found") @@ -286,7 +286,7 @@ private case class GBLeaf[A <% Ordered[A],B]() extends GBTree[A,B] { else ITree(GBNode(key, value, this, this)) } - def toList(acc: List[{A,B}]): List[{A,B}] = acc + def toList(acc: List[Pair[A,B]]): List[Pair[A,B]] = acc def mk_iter(iter_tail: List[GBTree[A,B]]) = iter_tail def merge(larger: GBTree[A,B]) = larger def takeSmallest: Triple[A,B, GBTree[A,B]] = @@ -301,14 +301,14 @@ private case class GBNode[A <% Ordered[A],B](key: A, smaller: GBTree[A,B], bigger: GBTree[A,B]) extends GBTree[A,B] { - def count: {Int,Int} = { - val {sHeight, sSize} = smaller.count - val {bHeight, bSize} = bigger.count + def count: Pair[Int,Int] = { + val Pair(sHeight, sSize) = smaller.count + val Pair(bHeight, bSize) = bigger.count val mySize = sSize + bSize + 1 if (mySize == 1) - {1, mySize} + Pair(1, mySize) else - {2 * compat.Math.max(sHeight, bHeight), mySize} + Pair(2 * compat.Math.max(sHeight, bHeight), mySize) } def isDefinedAt(sKey: A): Boolean = @@ -343,8 +343,8 @@ private case class GBNode[A <% Ordered[A],B](key: A, throw new NoSuchElementException("Key exists: " + newKey) } - def toList(acc: List[{A,B}]): List[{A,B}] = - smaller.toList({key, value} :: bigger.toList(acc)) + def toList(acc: List[Pair[A,B]]): List[Pair[A,B]] = + smaller.toList(Pair(key, value) :: bigger.toList(acc)) def mk_iter(iter_tail:List[aNode]):List[aNode] = smaller.mk_iter(this :: iter_tail) @@ -362,16 +362,16 @@ private case class GBNode[A <% Ordered[A],B](key: A, case GBLeaf() => this case _ => - val {key1, value1, larger1} = larger.takeSmallest + val Triple(key1, value1, larger1) = larger.takeSmallest GBNode(key1, value1, this, larger1) } def takeSmallest: Triple[A, B, aNode] = smaller match { case GBLeaf() => - {key, value, bigger} + Triple(key, value, bigger) case _ => - val {key1, value1, smaller1} = smaller.takeSmallest - {key1, value1, GBNode(key, value, smaller1, bigger)} + val Triple(key1, value1, smaller1) = smaller.takeSmallest + Triple(key1, value1, GBNode(key, value, smaller1, bigger)) } /** @@ -381,22 +381,22 @@ private case class GBNode[A <% Ordered[A],B](key: A, def balance(s: int): GBTree[A,B] = balance_list(toList(scala.Nil), s) - protected def balance_list(list: List[{A,B}], s: int): GBTree[A,B] = { + protected def balance_list(list: List[Pair[A,B]], s: int): GBTree[A,B] = { val empty = GBLeaf[A,B](); - def bal(list: List[{A,B}], s: Int): {aNode, List[{A,B}]} = { + def bal(list: List[Pair[A,B]], s: Int): Pair[aNode, List[Pair[A,B]]] = { if (s > 1) { val sm = s - 1 val s2 = sm / 2 val s1 = sm - s2 - val {t1, {k, v} :: l1} = bal(list, s1) - val {t2, l2} = bal(l1, s2) + val Pair(t1, Pair(k, v) :: l1) = bal(list, s1) + val Pair(t2, l2) = bal(l1, s2) val t = GBNode(k, v, t1, t2) - {t, l2} + Pair(t, l2) } else if (s == 1) { - val {k,v} :: rest = list - {GBNode(k, v, empty, empty), rest} + val Pair(k,v) :: rest = list + Pair(GBNode(k, v, empty, empty), rest) } else - {empty, list} + Pair(empty, list) } bal(list, s)._1 } diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala index 22664f1e20..9e43f092df 100644 --- a/src/library/scala/collection/immutable/TreeMap.scala +++ b/src/library/scala/collection/immutable/TreeMap.scala @@ -25,7 +25,7 @@ object TreeMap { /** The canonical factory for this type */ - def apply[A <% Ordered[A], B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A <% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems } /** This class implements immutable maps using a tree. @@ -104,7 +104,7 @@ extends RedBlack[A] with Map[A, B] { * * @return the new iterator */ - def elements: Iterator[{A, B}] = tree.elements + def elements: Iterator[Pair[A, B]] = tree.elements } diff --git a/src/library/scala/collection/immutable/UnbalancedTreeMap.scala b/src/library/scala/collection/immutable/UnbalancedTreeMap.scala index dabc3a11cf..965c4729c6 100755 --- a/src/library/scala/collection/immutable/UnbalancedTreeMap.scala +++ b/src/library/scala/collection/immutable/UnbalancedTreeMap.scala @@ -20,7 +20,7 @@ object UnbalancedTreeMap { /** The canonical factory for this type */ - def apply[A<% Ordered[A], B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A<% Ordered[A], B](elems: Pair[A, B]*) = empty[A, B] ++ elems } /** This class implements immutable maps using a tree. @@ -95,7 +95,7 @@ class UnbalancedTreeMap[A <% Ordered[A], +B] extends Map[A, B] { * * @return the new iterator */ - def elements: Iterator[{A, B}] = Iterator.empty + def elements: Iterator[Pair[A, B]] = Iterator.empty protected class Node[+B](override protected val key: A, override protected val value: B, @@ -133,8 +133,8 @@ class UnbalancedTreeMap[A <% Ordered[A], +B] extends Map[A, B] { } } - override def elements: Iterator[{A, B}] = - left.elements append Iterator.single({key, value}) append right.elements + override def elements: Iterator[Pair[A, B]] = + left.elements append Iterator.single(Pair(key, value)) append right.elements } } diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index e506e95994..f840fc3a2a 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -166,7 +166,7 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { case that: ArrayBuffer[_] => this.length == that.length && elements.zip(that.elements).forall { - case {thiselem, thatelem} => thiselem == thatelem + case Pair(thiselem, thatelem) => thiselem == thatelem } case _ => false diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala index fac9603438..5d8f24393c 100644 --- a/src/library/scala/collection/mutable/Buffer.scala +++ b/src/library/scala/collection/mutable/Buffer.scala @@ -25,7 +25,7 @@ import Predef._ [cloneable] trait Buffer[A] extends AnyRef with Seq[A] - with Scriptable[Message[{Location, A}]] + with Scriptable[Message[Pair[Location, A]]] { /** Append a single element to this buffer. @@ -202,20 +202,20 @@ trait Buffer[A] extends AnyRef * * @param cmd the message to send. */ - def <<(cmd: Message[{Location, A}]): Unit = cmd match { - case Include({l, elem}) => l match { + def <<(cmd: Message[Pair[Location, A]]): Unit = cmd match { + case Include(Pair(l, elem)) => l match { case Start => prepend(elem) case End => append(elem) case Index(n) => insert(n, elem) case _ => throw new UnsupportedOperationException("message " + cmd + " not understood") } - case Update({l, elem}) => l match { + case Update(Pair(l, elem)) => l match { case Start => update(0, elem) case End => update(length - 1, elem) case Index(n) => update(n, elem) case _ => throw new UnsupportedOperationException("message " + cmd + " not understood") } - case Remove({l, _}) => l match { + case Remove(Pair(l, _)) => l match { case Start => remove(0) case End => remove(length - 1) case Index(n) => remove(n) diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala index adf7162954..5f1d60e333 100644 --- a/src/library/scala/collection/mutable/BufferProxy.scala +++ b/src/library/scala/collection/mutable/BufferProxy.scala @@ -142,7 +142,7 @@ trait BufferProxy[A] extends Buffer[A] with Proxy { * * @param cmd the message to send. */ - override def <<(cmd: Message[{Location, A}]): Unit = self << cmd + override def <<(cmd: Message[Pair[Location, A]]): Unit = self << cmd /** Return a clone of this buffer. * diff --git a/src/library/scala/collection/mutable/DefaultMapModel.scala b/src/library/scala/collection/mutable/DefaultMapModel.scala index 9bf8b803b5..7148667849 100644 --- a/src/library/scala/collection/mutable/DefaultMapModel.scala +++ b/src/library/scala/collection/mutable/DefaultMapModel.scala @@ -40,6 +40,6 @@ trait DefaultMapModel[A, B] extends Map[A, B] { else e.value = value } - def elements = entries map {e => {e.key, e.value}} + def elements = entries map {e => Pair(e.key, e.value)} } diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala index 59a8b8a860..863a535aef 100644 --- a/src/library/scala/collection/mutable/HashMap.scala +++ b/src/library/scala/collection/mutable/HashMap.scala @@ -26,7 +26,7 @@ object HashMap { /** The canonical factory for this type */ - def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems } [serializable] diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala index dbafbf29dc..4143e6e9de 100644 --- a/src/library/scala/collection/mutable/History.scala +++ b/src/library/scala/collection/mutable/History.scala @@ -21,9 +21,9 @@ package scala.collection.mutable * @version 1.0, 08/07/2003 */ [serializable] -class History[A, B] extends AnyRef with Subscriber[A, B] with Iterable[{B, A}] { +class History[A, B] extends AnyRef with Subscriber[A, B] with Iterable[Pair[B, A]] { - protected val log: Queue[{B, A}] = new Queue[{B, A}] + protected val log: Queue[Pair[B, A]] = new Queue[Pair[B, A]] val maxHistory: Int = 1000 @@ -35,12 +35,12 @@ class History[A, B] extends AnyRef with Subscriber[A, B] with Iterable[{B, A}] { if (log.length >= maxHistory) { val old = log.dequeue; } - log.enqueue({pub, event}) + log.enqueue(Pair(pub, event)) } - def elements: Iterator[{B, A}] = log.elements + def elements: Iterator[Pair[B, A]] = log.elements - def events: Iterator[A] = log.elements.map { case {_, e} => e } + def events: Iterator[A] = log.elements.map { case Pair(_, e) => e } def size: Int = log.length diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala index 9328f19629..37bbb9dce4 100644 --- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala @@ -45,9 +45,9 @@ extends Map[A, B] override def values: Iterator[B] = imap.values - def elements: Iterator[{A, B}] = imap.elements + def elements: Iterator[Pair[A, B]] = imap.elements - override def toList: List[{A, B}] = imap.toList + override def toList: List[Pair[A, B]] = imap.toList def update(key: A, value: B): Unit = { imap = imap.update(key, value) } diff --git a/src/library/scala/collection/mutable/JavaMapAdaptor.scala b/src/library/scala/collection/mutable/JavaMapAdaptor.scala index 825758b64b..9b918836da 100644 --- a/src/library/scala/collection/mutable/JavaMapAdaptor.scala +++ b/src/library/scala/collection/mutable/JavaMapAdaptor.scala @@ -45,12 +45,12 @@ class JavaMapAdaptor[A, B](jmap: java.util.Map) extends Map[A, B] { def next = iter.next().asInstanceOf[B] } - def elements: Iterator[{A, B}] = new Iterator[{A, B}] { + def elements: Iterator[Pair[A, B]] = new Iterator[Pair[A, B]] { val iter = jmap.keySet().iterator() def hasNext = iter.hasNext() def next = { val key = iter.next().asInstanceOf[A] - {key, apply(key)} + Pair(key, apply(key)) } } diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index 2f4b95f55f..55bd75d3fd 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -268,7 +268,7 @@ final class ListBuffer[A] extends Buffer[A] { case that: ListBuffer[_] => (this.length == that.length && elements.zip(that.elements).forall { - case {thiselem, thatelem} => thiselem == thatelem + case Pair(thiselem, thatelem) => thiselem == thatelem }) case _ => false diff --git a/src/library/scala/collection/mutable/Map.scala b/src/library/scala/collection/mutable/Map.scala index 8b0342e5d6..85b178fa82 100644 --- a/src/library/scala/collection/mutable/Map.scala +++ b/src/library/scala/collection/mutable/Map.scala @@ -32,13 +32,13 @@ object Map { /** The canonical factory for this type */ - def apply[A, B](elems: {A, B}*) = empty[A, B] ++ elems + def apply[A, B](elems: Pair[A, B]*) = empty[A, B] ++ elems } [cloneable] trait Map[A, B] extends AnyRef with collection.Map[A, B] - with Scriptable[Message[{A, B}]] + with Scriptable[Message[Pair[A, B]]] { /** This method allows one to add a new mapping from key * to value to the map. If the map already contains a @@ -53,30 +53,30 @@ trait Map[A, B] extends AnyRef /** Add a key/value pair to this map. * @param kv the key/value pair. */ - def += (kv: {A, B}) { update(kv._1, kv._2) } + def += (kv: Pair[A, B]) { update(kv._1, kv._2) } /** Add two or more key/value pairs to this map. * @param kv1 the first key/value pair. * @param kv2 the second key/value pair. * @param kvs the remaining key/value pairs. */ - def += (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*) { this += kv1; this += kv2; this ++= kvs } + def += (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*) { this += kv1; this += kv2; this ++= kvs } /** Add a sequence of key/value pairs to this map. * @param kvs the iterable object containing all key/value pairs. */ - def ++= (kvs: Iterable[{A, B}]) { this ++= kvs.elements } + def ++= (kvs: Iterable[Pair[A, B]]) { this ++= kvs.elements } /** Add a sequence of key/value pairs to this map. * @param kvs the iterator containing all key/value pairs. */ - def ++= (kvs: Iterator[{A, B}]) { kvs foreach += } + def ++= (kvs: Iterator[Pair[A, B]]) { kvs foreach += } /** Add a key/value pair to this map. * @param kv the key/value pair. * @return The map itself with the new binding added in place. */ - def + (kv: {A, B}): Map[A, B] = { this += kv; this } + def + (kv: Pair[A, B]): Map[A, B] = { this += kv; this } /** Add two or more key/value pairs to this map. * @param kv1 the first key/value pair. @@ -84,7 +84,7 @@ trait Map[A, B] extends AnyRef * @param kvs the remaining key/value pairs. * @return The map itself with the new bindings added in place. */ - def + (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*): Map[A, B] = { + def + (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*): Map[A, B] = { this.+=(kv1, kv2, kvs: _*); this } @@ -92,13 +92,13 @@ trait Map[A, B] extends AnyRef * @param kvs the iterable object containing all key/value pairs. * @return The itself map with the new bindings added in place. */ - def ++ (kvs: Iterable[{A, B}]): Map[A, B] = { this ++= kvs; this } + def ++ (kvs: Iterable[Pair[A, B]]): Map[A, B] = { this ++= kvs; this } /** Add a sequence of key/value pairs to this map. * @param kvs the iterator containing all key/value pairs. * @return The itself map with the new bindings added in place. */ - def ++ (kvs: Iterator[{A, B}]): Map[A, B] = { this ++= kvs; this } + def ++ (kvs: Iterator[Pair[A, B]]): Map[A, B] = { this ++= kvs; this } /** Remove a key from this map, noop if key is not present. * @param key the key to be removed @@ -161,7 +161,7 @@ trait Map[A, B] extends AnyRef */ def transform(f: (A, B) => B) { elements foreach { - case {key, value} => update(key, f(key, value)) + case Pair(key, value) => update(key, f(key, value)) } } @@ -171,17 +171,17 @@ trait Map[A, B] extends AnyRef * @param p The test predicate */ def retain(p: (A, B) => Boolean): Unit = toList foreach { - case {key, value} => if (!p(key, value)) -=(key) + case Pair(key, value) => if (!p(key, value)) -=(key) } /** Send a message to this scriptable object. * * @param cmd the message to send. */ - def <<(cmd: Message[{A, B}]): Unit = cmd match { - case Include({k, v}) => update(k, v) - case Update({k, v}) => update(k, v) - case Remove({k, _}) => this -= k + def <<(cmd: Message[Pair[A, B]]): Unit = cmd match { + case Include(Pair(k, v)) => update(k, v) + case Update(Pair(k, v)) => update(k, v) + case Remove(Pair(k, _)) => this -= k case Reset() => clear case s: Script[_] => s.elements foreach << case _ => throw new UnsupportedOperationException("message " + cmd + " not understood") @@ -210,7 +210,7 @@ trait Map[A, B] extends AnyRef * @param mappings * @deprecated use += */ - [deprecated] def incl(mappings: {A, B}*): Unit = this ++= mappings.elements + [deprecated] def incl(mappings: Pair[A, B]*): Unit = this ++= mappings.elements /** This method will remove all the mappings for the given sequence * of keys from the map. @@ -226,9 +226,9 @@ trait Map[A, B] extends AnyRef * @deprecated use retain instead * @param p */ - [deprecated] override def filter(p: {A, B} => Boolean): Iterable[{A, B}] = { + [deprecated] override def filter(p: Pair[A, B] => Boolean): Iterable[Pair[A, B]] = { toList foreach { - case kv @ {key, _} => if (!p(kv)) -=(key) + case kv @ Pair(key, _) => if (!p(kv)) -=(key) } this } diff --git a/src/library/scala/collection/mutable/MapProxy.scala b/src/library/scala/collection/mutable/MapProxy.scala index deea498609..431a9d5273 100644 --- a/src/library/scala/collection/mutable/MapProxy.scala +++ b/src/library/scala/collection/mutable/MapProxy.scala @@ -30,14 +30,14 @@ trait MapProxy[A, B] extends Map[A, B] with collection.MapProxy[A, B] { def self: Map[A, B] override def update(key: A, value: B): Unit = self.update(key, value) - override def += (kv: {A, B}) = self += kv - override def += (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*) = self.+=(kv1, kv2, kvs: _*) - override def ++= (kvs: Iterable[{A, B}]) = self ++= kvs - override def ++= (kvs: Iterator[{A, B}]) = self ++= kvs - override def + (kv: {A, B}): Map[A, B] = self + kv - override def + (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*): Map[A, B] = self.+(kv1, kv2, kvs: _*) - override def ++ (kvs: Iterable[{A, B}]): Map[A, B] = self ++ kvs - override def ++ (kvs: Iterator[{A, B}]): Map[A, B] = self ++ kvs + override def += (kv: Pair[A, B]) = self += kv + override def += (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*) = self.+=(kv1, kv2, kvs: _*) + override def ++= (kvs: Iterable[Pair[A, B]]) = self ++= kvs + override def ++= (kvs: Iterator[Pair[A, B]]) = self ++= kvs + override def + (kv: Pair[A, B]): Map[A, B] = self + kv + override def + (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*): Map[A, B] = self.+(kv1, kv2, kvs: _*) + override def ++ (kvs: Iterable[Pair[A, B]]): Map[A, B] = self ++ kvs + override def ++ (kvs: Iterator[Pair[A, B]]): Map[A, B] = self ++ kvs override def -= (key: A) = self -= key override def -= (key1: A, key2: A, keys: A*) = self.-=(key1, key2, keys: _*) override def --= (keys: Iterable[A]) = self --= keys @@ -49,8 +49,8 @@ trait MapProxy[A, B] extends Map[A, B] with collection.MapProxy[A, B] { override def clear(): Unit = self.clear override def transform(f: (A, B) => B) = self transform f override def retain(p: (A, B) => Boolean): Unit = self retain p - override def <<(cmd: Message[{A, B}]): Unit = self << cmd + override def <<(cmd: Message[Pair[A, B]]): Unit = self << cmd override def clone(): Map[A, B] = self.clone() - [deprecated] override def incl(mappings: {A, B}*): Unit = self.incl(mappings: _*) + [deprecated] override def incl(mappings: Pair[A, B]*): Unit = self.incl(mappings: _*) [deprecated] override def excl(keys: A*): Unit = self.excl(keys: _*) } diff --git a/src/library/scala/collection/mutable/ObservableBuffer.scala b/src/library/scala/collection/mutable/ObservableBuffer.scala index 0aa15611a6..57f474f6e8 100644 --- a/src/library/scala/collection/mutable/ObservableBuffer.scala +++ b/src/library/scala/collection/mutable/ObservableBuffer.scala @@ -24,13 +24,13 @@ package scala.collection.mutable */ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This extends Buffer[A] - with Publisher[Message[{Location, A}] + with Publisher[Message[Pair[Location, A]] with Undoable, This] { abstract override def +(element: A): Buffer[A] = { super.+(element) - publish(new Include({End, element}) with Undoable { + publish(new Include(Pair(End, element)) with Undoable { def undo: Unit = trimEnd(1) }) this @@ -38,7 +38,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This abstract override def +:(element: A): Buffer[A] = { super.+:(element); - publish(new Include({Start, element}) with Undoable { + publish(new Include(Pair(Start, element)) with Undoable { def undo: Unit = trimStart(1) }) this @@ -49,7 +49,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This var i = n val it = iter.elements while (it.hasNext) { - publish(new Include({Index(i), it.next}) with Undoable { + publish(new Include(Pair(Index(i), it.next)) with Undoable { def undo: Unit = remove(i); }) i = i + 1 @@ -59,7 +59,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This abstract override def update(n: Int, newelement: A): Unit = { val oldelement = apply(n) super.update(n, newelement) - publish(new Update({Index(n), newelement}) with Undoable { + publish(new Update(Pair(Index(n), newelement)) with Undoable { def undo: Unit = update(n, oldelement) }) } @@ -67,7 +67,7 @@ trait ObservableBuffer[A, This <: ObservableBuffer[A, This]] requires This abstract override def remove(n: Int): A = { val oldelement = apply(n) super.remove(n) - publish(new Remove({Index(n), oldelement}) with Undoable { + publish(new Remove(Pair(Index(n), oldelement)) with Undoable { def undo: Unit = insert(n, oldelement) }) oldelement diff --git a/src/library/scala/collection/mutable/ObservableMap.scala b/src/library/scala/collection/mutable/ObservableMap.scala index 626129343c..988eaf67c6 100644 --- a/src/library/scala/collection/mutable/ObservableMap.scala +++ b/src/library/scala/collection/mutable/ObservableMap.scala @@ -23,19 +23,19 @@ package scala.collection.mutable */ trait ObservableMap[A, B, This <: ObservableMap[A, B, This]] requires This extends Map[A, B] - with Publisher[Message[{A, B}] + with Publisher[Message[Pair[A, B]] with Undoable, This] { abstract override def update(key: A, value: B): Unit = get(key) match { case None => super.update(key, value) - publish(new Include({key, value}) with Undoable { + publish(new Include(Pair(key, value)) with Undoable { def undo = -=(key) }) case Some(old) => super.update(key, value) - publish(new Update({key, value}) with Undoable { + publish(new Update(Pair(key, value)) with Undoable { def undo = update(key, old) }) } @@ -44,7 +44,7 @@ trait ObservableMap[A, B, This <: ObservableMap[A, B, This]] requires This case None => case Some(old) => super.-=(key) - publish(new Remove({key, old}) with Undoable { + publish(new Remove(Pair(key, old)) with Undoable { def undo = update(key, old) }) } diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index 64a5ea0ddc..4f67392381 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -157,7 +157,7 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] { that.isInstanceOf[PriorityQueue[A]] && { val other = that.asInstanceOf[PriorityQueue[A]] elements.zip(other.elements).forall { - case {thiselem, thatelem} => thiselem == thatelem + case Pair(thiselem, thatelem) => thiselem == thatelem }} /** The hashCode method always yields an error, since it is not diff --git a/src/library/scala/collection/mutable/Queue.scala b/src/library/scala/collection/mutable/Queue.scala index e2b4d8d913..7c34c1f2ae 100644 --- a/src/library/scala/collection/mutable/Queue.scala +++ b/src/library/scala/collection/mutable/Queue.scala @@ -167,7 +167,7 @@ class Queue[A] extends MutableList[A] { that.isInstanceOf[Queue[A]] && { val other = that.asInstanceOf[Queue[A]] elements.zip(other.elements).forall { - case {thiselem, thatelem} => thiselem == thatelem + case Pair(thiselem, thatelem) => thiselem == thatelem }} /** The hashCode method always yields an error, since it is not diff --git a/src/library/scala/collection/mutable/RevertableHistory.scala b/src/library/scala/collection/mutable/RevertableHistory.scala index f9fcb635b6..9ad19dedc7 100644 --- a/src/library/scala/collection/mutable/RevertableHistory.scala +++ b/src/library/scala/collection/mutable/RevertableHistory.scala @@ -28,6 +28,6 @@ class RevertableHistory[A <: Undoable, B] extends History[A, B] with Undoable { def undo: Unit = { val old = log.toList.reverse clear - old.foreach { case {sub, event} => event.undo } + old.foreach { case Pair(sub, event) => event.undo } } } diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index 1aee74148e..e3890d22df 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -109,7 +109,7 @@ class Stack[A] extends MutableList[A] { that.isInstanceOf[Stack[A]] && { val other = that.asInstanceOf[Stack[A]]; elements.zip(other.elements).forall { - case {thiselem, thatelem} => thiselem == thatelem + case Pair(thiselem, thatelem) => thiselem == thatelem }} /** The hashCode method always yields an error, since it is not diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala index b86f7d401b..652c6d535b 100644 --- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala +++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala @@ -168,7 +168,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] { super.clear } - override def <<(cmd: Message[{Location, A}]): Unit = synchronized { + override def <<(cmd: Message[Pair[Location, A]]): Unit = synchronized { super.<<(cmd) } diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala index da317123f0..785e061a4e 100644 --- a/src/library/scala/collection/mutable/SynchronizedMap.scala +++ b/src/library/scala/collection/mutable/SynchronizedMap.scala @@ -57,11 +57,11 @@ trait SynchronizedMap[A, B] extends Map[A, B] { super.values } - abstract override def elements: Iterator[{A, B}] = synchronized { + abstract override def elements: Iterator[Pair[A, B]] = synchronized { super.elements } - override def toList: List[{A, B}] = synchronized { + override def toList: List[Pair[A, B]] = synchronized { super.toList } @@ -69,7 +69,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] { super.update(key, value) } - override def += (kv: {A, B}): Unit = synchronized { + override def += (kv: Pair[A, B]): Unit = synchronized { super.+=(kv) } @@ -78,19 +78,19 @@ trait SynchronizedMap[A, B] extends Map[A, B] { * @param kv2 the second key/first value pair. * @param kvs the remaining key/first value pairs. */ - override def += (kv1: {A, B}, kv2: {A, B}, kvs: {A, B}*): Unit = synchronized { + override def += (kv1: Pair[A, B], kv2: Pair[A, B], kvs: Pair[A, B]*): Unit = synchronized { super.+=(kv1, kv2, kvs: _*) } - override def ++=(map: Iterable[{A, B}]): Unit = synchronized { + override def ++=(map: Iterable[Pair[A, B]]): Unit = synchronized { super.++=(map) } - override def ++=(it: Iterator[{A, B}]): Unit = synchronized { + override def ++=(it: Iterator[Pair[A, B]]): Unit = synchronized { super.++=(it) } - [deprecated] override def incl(mappings: {A, B}*): Unit = synchronized { + [deprecated] override def incl(mappings: Pair[A, B]*): Unit = synchronized { super.incl(mappings: _*) } @@ -122,7 +122,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] { super.transform(f) } - [deprecated] override def map[C](f: {A, B} => C) = synchronized { + [deprecated] override def map[C](f: Pair[A, B] => C) = synchronized { super.map(f) } @@ -131,7 +131,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] { } /** @deprecated use retain instead */ - [deprecated] override def filter(p: {A, B} => Boolean) = synchronized { + [deprecated] override def filter(p: Pair[A, B] => Boolean) = synchronized { super.filter(p) } @@ -147,7 +147,7 @@ trait SynchronizedMap[A, B] extends Map[A, B] { super.hashCode() } - override def <<(cmd: Message[{A, B}]): Unit = synchronized { + override def <<(cmd: Message[Pair[A, B]]): Unit = synchronized { super.<<(cmd) } diff --git a/src/library/scala/concurrent/MailBox.scala b/src/library/scala/concurrent/MailBox.scala index b6ba205fa2..e1399e9e58 100644 --- a/src/library/scala/concurrent/MailBox.scala +++ b/src/library/scala/concurrent/MailBox.scala @@ -58,7 +58,7 @@ class MailBox extends AnyRef with ListQueueCreator { private def scanSentMsgs[a](receiver: Receiver[a]): unit = synchronized { messageQueue.extractFirst(sent, msg => receiver.isDefinedAt(msg)) match { case None => receivers = receiverQueue.append(receivers, receiver) - case Some{msg, withoutMsg} => { + case Some(Pair(msg, withoutMsg)) => { sent = withoutMsg receiver.msg = msg } @@ -73,7 +73,7 @@ class MailBox extends AnyRef with ListQueueCreator { def send(msg: Message): unit = synchronized { receiverQueue.extractFirst(receivers, r => r.isDefinedAt(msg)) match { case None => sent = messageQueue.append(sent, msg) - case Some{receiver, withoutReceiver} => { + case Some(Pair(receiver, withoutReceiver)) => { receivers = withoutReceiver receiver.msg = msg receiver synchronized { receiver.notify() } @@ -116,7 +116,7 @@ trait QueueModule[a] { /** Append an element to a queue. */ def append(l: t, x: a): t /** Extract an element satisfying a predicate from a queue. */ - def extractFirst(l: t, p: a => boolean): Option[{a, t}] + def extractFirst(l: t, p: a => boolean): Option[Pair[a, t]] } /** Inefficient but simple queue module creator. */ @@ -125,16 +125,16 @@ trait ListQueueCreator { type t = List[a] def make: t = Nil def append(l: t, x: a): t = l ::: x :: Nil - def extractFirst(l: t, p: a => boolean): Option[{a, t}] = + def extractFirst(l: t, p: a => boolean): Option[Pair[a, t]] = l match { case Nil => None case head :: tail => if (p(head)) - Some{head, tail} + Some(Pair(head, tail)) else extractFirst(tail, p) match { case None => None - case Some{x, without_x} => Some{x, head :: without_x} + case Some(Pair(x, without_x)) => Some(Pair(x, head :: without_x)) } } } @@ -144,17 +144,17 @@ trait ListQueueCreator { trait LinkedListQueueCreator { import scala.collection.mutable.LinkedList def queueCreate[a >: Null <: AnyRef]: QueueModule[a] = new QueueModule[a] { - type t = {LinkedList[a], LinkedList[a]} // fst = the list, snd = last elem + type t = Pair[LinkedList[a], LinkedList[a]] // fst = the list, snd = last elem def make: t = { val l = new LinkedList[a](null, null) - {l, l} + Pair(l, l) } def append(l: t, x: a): t = { val atTail = new LinkedList(x, null) l._2 append atTail; - {l._1, atTail} + Pair(l._1, atTail) } - def extractFirst(l: t, p: a => boolean): Option[{a, t}] = { + def extractFirst(l: t, p: a => boolean): Option[Pair[a, t]] = { var xs = l._1 var xs1 = xs.next while ((xs1 ne null) && !p(xs1.elem)) { @@ -166,7 +166,7 @@ trait LinkedListQueueCreator { if (xs.next eq null) Some(Pair(xs1.elem, Pair(l._1, xs))) else - Some{xs1.elem, l} + Some(Pair(xs1.elem, l)) } else None diff --git a/src/library/scala/concurrent/Process.scala b/src/library/scala/concurrent/Process.scala index 3e8589e7ef..6aa2e5ff53 100644 --- a/src/library/scala/concurrent/Process.scala +++ b/src/library/scala/concurrent/Process.scala @@ -68,7 +68,7 @@ class Process(body: => Unit) extends Actor() { } private def signal(s: MailBox#Message) = - links.foreach { p: Process => p.send({'EXIT, this, s}) } + links.foreach { p: Process => p.send(Triple('EXIT, this, s)) } def !(msg: MailBox#Message) = send(msg) diff --git a/src/library/scala/concurrent/jolib.scala b/src/library/scala/concurrent/jolib.scala index afa23c0cb3..d26190da20 100644 --- a/src/library/scala/concurrent/jolib.scala +++ b/src/library/scala/concurrent/jolib.scala @@ -28,7 +28,7 @@ object jolib { class Join { - private var ruls: List[{Pattern, Rule}] = null + private var ruls: List[Pair[Pattern, Rule]] = null def canMatch(p: Pattern) = p forall { s => !s.queue.isEmpty } @@ -36,13 +36,13 @@ object jolib { def values(p: Pattern): List[Any] = p map { s => s.queue.dequeue: Any } - def rules(rs: {Pattern, Rule}*) = - ruls = rs.asInstanceOf[List[{Pattern, Rule}]] + def rules(rs: Pair[Pattern, Rule]*) = + ruls = rs.asInstanceOf[List[Pair[Pattern, Rule]]] def tryMatch = - (ruls find { case {p, _} => canMatch(p) }) match { + ruls find { case Pair(p, _) => canMatch(p) } match { case None => () => () - case Some{p, r} => { + case Some(Pair(p, r)) => { val args = values(p) () => concurrent.ops.spawn(r(args)) } diff --git a/src/library/scala/concurrent/ops.scala b/src/library/scala/concurrent/ops.scala index 1c5b0e1713..73cfedc676 100644 --- a/src/library/scala/concurrent/ops.scala +++ b/src/library/scala/concurrent/ops.scala @@ -44,10 +44,10 @@ object ops { * @param yp ... * @return ... */ - def par[a, b](xp: => a, yp: => b): {a, b} = { + def par[a, b](xp: => a, yp: => b): Pair[a, b] = { val y = new SyncVar[b] spawn { y set yp } - {xp, y.get} + Pair(xp, y.get) } /** diff --git a/src/library/scala/concurrent/pilib.scala b/src/library/scala/concurrent/pilib.scala index bc76821884..449eb4f0fc 100644 --- a/src/library/scala/concurrent/pilib.scala +++ b/src/library/scala/concurrent/pilib.scala @@ -157,13 +157,13 @@ object pilib { * @param gs2 ... * @return ... */ - private def matches(gs1: List[UGP], gs2: List[UGP]): Option[{() => unit, () => Any, () => Any}] = - {gs1, gs2} match { - case {Nil, _} => None - case {_, Nil} => None - case {UGP(a1, d1, v1, c1) :: rest1, UGP(a2, d2, v2, c2) :: rest2} => + private def matches(gs1: List[UGP], gs2: List[UGP]): Option[Triple[() => unit, () => Any, () => Any]] = + Pair(gs1, gs2) match { + case Pair(Nil, _) => None + case Pair(_, Nil) => None + case Pair(UGP(a1, d1, v1, c1) :: rest1, UGP(a2, d2, v2, c2) :: rest2) => if (a1 == a2 && d1 == !d2) - Some{(() => if (d1) a1.log(v2) else a1.log(v1)), (() => c1(v2)), (() => c2(v1))} + Some(Triple((() => if (d1) a1.log(v2) else a1.log(v1)), (() => c1(v2)), (() => c2(v1)))) else matches(gs1, rest2) match { case None => matches(rest1, gs2) case Some(t) => Some(t) @@ -183,7 +183,7 @@ object pilib { case Nil => ss ::: List(s1) case s2 :: rest => matches(s1.gs, s2.gs) match { case None => s2 :: compare(s1, rest) - case Some{log, c1, c2} => + case Some(Triple(log, c1, c2)) => log() s1.set(c1) s2.set(c2) diff --git a/src/library/scala/mobile/Code.scala b/src/library/scala/mobile/Code.scala index 2f2b6c3832..e90d7015a3 100644 --- a/src/library/scala/mobile/Code.scala +++ b/src/library/scala/mobile/Code.scala @@ -158,17 +158,17 @@ class Code(clazz: java.lang.Class) { ////////////////////// private functions /////////////////////// private def boxValue(value: Any) = value match { - case x: Byte => {new java.lang.Byte(x), java.lang.Byte.TYPE} - case x: Boolean => {new java.lang.Boolean(x), java.lang.Boolean.TYPE} - case x: Char => {new java.lang.Character(x), java.lang.Character.TYPE} - case x: Short => {new java.lang.Short(x), java.lang.Short.TYPE} - case x: Int => {new java.lang.Integer(x), java.lang.Integer.TYPE} - case x: Long => {new java.lang.Long(x), java.lang.Long.TYPE} - case x: Float => {new java.lang.Float(x), java.lang.Float.TYPE} - case x: Double => {new java.lang.Double(x), java.lang.Double.TYPE} + case x: Byte => Pair(new java.lang.Byte(x), java.lang.Byte.TYPE) + case x: Boolean => Pair(new java.lang.Boolean(x), java.lang.Boolean.TYPE) + case x: Char => Pair(new java.lang.Character(x), java.lang.Character.TYPE) + case x: Short => Pair(new java.lang.Short(x), java.lang.Short.TYPE) + case x: Int => Pair(new java.lang.Integer(x), java.lang.Integer.TYPE) + case x: Long => Pair(new java.lang.Long(x), java.lang.Long.TYPE) + case x: Float => Pair(new java.lang.Float(x), java.lang.Float.TYPE) + case x: Double => Pair(new java.lang.Double(x), java.lang.Double.TYPE) case _ => val x = value.asInstanceOf[JObject] - {x, x.getClass()} + Pair(x, x.getClass()) } private def isConstructorName(methName: String) = { diff --git a/src/library/scala/reflect/Type.scala b/src/library/scala/reflect/Type.scala index fb1acbc650..de5dc52479 100644 --- a/src/library/scala/reflect/Type.scala +++ b/src/library/scala/reflect/Type.scala @@ -41,7 +41,7 @@ case class TypeBounds(lo: Type, hi: Type) extends Type case class MethodType(formals: List[Type], restpe: Type) extends Type /** */ -case class PolyType(typeParams: List[Symbol], typeBounds: List[{Type, Type}], resultType: Type) extends Type +case class PolyType(typeParams: List[Symbol], typeBounds: List[Pair[Type, Type]], resultType: Type) extends Type /** */ class ImplicitMethodType(formals: List[Type], restpe: Type) diff --git a/src/library/scala/text/Document.scala b/src/library/scala/text/Document.scala index 4818c342fd..70e7bc8fc7 100644 --- a/src/library/scala/text/Document.scala +++ b/src/library/scala/text/Document.scala @@ -50,20 +50,20 @@ abstract class Document { false case List() => true - case {_, _, DocNil} :: z => + case Triple(_, _, DocNil) :: z => fits(w, z) - case {i, b, DocCons(h, t)} :: z => - fits(w, {i,b,h} :: {i,b,t} :: z) - case {_, _, DocText(t)} :: z => + case Triple(i, b, DocCons(h, t)) :: z => + fits(w, Triple(i,b,h) :: Triple(i,b,t) :: z) + case Triple(_, _, DocText(t)) :: z => fits(w - t.length(), z) - case {i, b, DocNest(ii, d)} :: z => - fits(w, {i + ii, b, d} :: z) - case {_, false, DocBreak} :: z => + case Triple(i, b, DocNest(ii, d)) :: z => + fits(w, Triple(i + ii, b, d) :: z) + case Triple(_, false, DocBreak) :: z => fits(w - 1, z) - case {_, true, DocBreak} :: z => + case Triple(_, true, DocBreak) :: z => true - case {i, _, DocGroup(d)} :: z => - fits(w, {i, false, d} :: z) + case Triple(i, _, DocGroup(d)) :: z => + fits(w, Triple(i, false, d) :: z) } def spaces(n: Int): Unit = { @@ -77,28 +77,28 @@ abstract class Document { def fmt(k: Int, state: List[FmtState]): Unit = state match { case List() => () - case {_, _, DocNil} :: z => + case Triple(_, _, DocNil) :: z => fmt(k, z) - case {i, b, DocCons(h, t)} :: z => - fmt(k, {i, b, h} :: {i, b, t} :: z) - case {i, _, DocText(t)} :: z => + case Triple(i, b, DocCons(h, t)) :: z => + fmt(k, Triple(i, b, h) :: Triple(i, b, t) :: z) + case Triple(i, _, DocText(t)) :: z => writer write t fmt(k + t.length(), z) - case {i, b, DocNest(ii, d)} :: z => - fmt(k, {i + ii, b, d} :: z) - case {i, true, DocBreak} :: z => + case Triple(i, b, DocNest(ii, d)) :: z => + fmt(k, Triple(i + ii, b, d) :: z) + case Triple(i, true, DocBreak) :: z => writer write "\n" spaces(i); fmt(i, z) - case {i, false, DocBreak} :: z => + case Triple(i, false, DocBreak) :: z => writer write " " fmt(k + 1, z) - case {i, b, DocGroup(d)} :: z => - val fitsFlat = fits(width - k, {i, false, d} :: z) - fmt(k, {i, !fitsFlat, d} :: z) + case Triple(i, b, DocGroup(d)) :: z => + val fitsFlat = fits(width - k, Triple(i, false, d) :: z) + fmt(k, Triple(i, !fitsFlat, d) :: z) } - fmt(0, {0, false, DocGroup(this)} :: Nil) + fmt(0, Triple(0, false, DocGroup(this)) :: Nil) } } diff --git a/test/files/neg/patmatexhaust.scala b/test/files/neg/patmatexhaust.scala index 7370868363..e1b52a61ef 100644 --- a/test/files/neg/patmatexhaust.scala +++ b/test/files/neg/patmatexhaust.scala @@ -21,10 +21,10 @@ class TestSealedExhaustive { // compile only case Kult(_) => // exhaustive } def ma3(x:Mult) = {x,x} match { // not exhaustive - case {Kult(_), Qult()} => // Kult missing - //case {Kult(_), Kult(_)} => - case {Qult(), Kult(_)} => // Qult missing - //case {Qult(), Qult()} => + case Pair(Kult(_), Qult()) => // Kult missing + //case Pair(Kult(_), Kult(_)) => + case Pair(Qult(), Kult(_)) => // Qult missing + //case Pair(Qult(), Qult()) => } sealed class Deep diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala index 9dc73a86de..e77e10abeb 100644 --- a/test/files/run/patmatnew.scala +++ b/test/files/run/patmatnew.scala @@ -100,9 +100,9 @@ object Test { // these are exhaustive matches // should not generate any warnings def f[A](z:{Option[A],Option[A]}) = z match { - case {None,Some(x)} => 1 - case {Some(x),None } => 2 - case {Some(x),Some(y)} => 3 + case Pair(None,Some(x)) => 1 + case Pair(Some(x),None ) => 2 + case Pair(Some(x),Some(y)) => 3 case _ => 4 } @@ -119,9 +119,9 @@ object Test { } def h[A](x:{Option[A],Option[A]}) = x match { - case {None,_:Some[_]} => 1 - case {_:Some[_],None } => 2 - case {_:Some[_],_:Some[_]} => 3 + case Pair(None,_:Some[_]) => 1 + case Pair(_:Some[_],None ) => 2 + case Pair(_:Some[_],_:Some[_]) => 3 case _ => 4 } diff --git a/test/files/run/tuples.scala b/test/files/run/tuples.scala index c6dcda4af8..3d0dcf7ac0 100644 --- a/test/files/run/tuples.scala +++ b/test/files/run/tuples.scala @@ -1,8 +1,8 @@ object Test extends Application { - var xyz: {int, String, boolean} = _ - xyz = { 1, "abc", true } + var xyz: Triple(int, String, boolean) = _ + xyz = Triple(1, "abc", true) Console.println(xyz) xyz match { - case { 1, "abc", true } => Console.println("OK") + case Triple(1, "abc", true) => Console.println("OK") } } -- cgit v1.2.3