diff options
Diffstat (limited to 'src')
12 files changed, 91 insertions, 41 deletions
diff --git a/src/compiler/scala/reflect/reify/codegen/Types.scala b/src/compiler/scala/reflect/reify/codegen/Types.scala index 1f336f4b0f..a2b074c6b2 100644 --- a/src/compiler/scala/reflect/reify/codegen/Types.scala +++ b/src/compiler/scala/reflect/reify/codegen/Types.scala @@ -99,7 +99,7 @@ trait Types { // if this fails, it might produce the dreaded "erroneous or inaccessible type" error // to find out the whereabouts of the error run scalac with -Ydebug if (reifyDebug) println("launching implicit search for %s.%s[%s]".format(prefix, tagClass.name, tpe)) - typer.resolveTypeTag(defaultErrorPosition, prefix.tpe, tpe, concrete) match { + typer.resolveTypeTag(prefix.tpe, tpe, defaultErrorPosition, concrete) match { case failure if failure.isEmpty => if (reifyDebug) println("implicit search was fruitless") EmptyTree diff --git a/src/compiler/scala/reflect/reify/package.scala b/src/compiler/scala/reflect/reify/package.scala index 3f9d6200cd..f3040ad79c 100644 --- a/src/compiler/scala/reflect/reify/package.scala +++ b/src/compiler/scala/reflect/reify/package.scala @@ -33,8 +33,8 @@ package object reify { import definitions._ import analyzer.enclosingMacroPosition - def erasureTagInScope = typer0.context.withMacrosDisabled(typer0.resolveErasureTag(enclosingMacroPosition, tpe, concrete = concrete)) - def arrayTagInScope = typer0.context.withMacrosDisabled(typer0.resolveArrayTag(enclosingMacroPosition, tpe)) + def erasureTagInScope = typer0.context.withMacrosDisabled(typer0.resolveErasureTag(tpe, enclosingMacroPosition, concrete = concrete)) + def arrayTagInScope = typer0.context.withMacrosDisabled(typer0.resolveArrayTag(tpe, enclosingMacroPosition)) val inScope = (erasureTagInScope, arrayTagInScope) inScope match { diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index 338c39dc5f..b8e43dfc50 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -997,7 +997,7 @@ abstract class Erasure extends AddInterfaces } // Rewrite 5.getClass to ScalaRunTime.anyValClass(5) else if (isPrimitiveValueClass(qual.tpe.typeSymbol)) - global.typer.typed(gen.mkRuntimeCall(nme.anyValClass, List(qual, typer.resolveErasureTag(tree.pos, qual.tpe.widen, true)))) + global.typer.typed(gen.mkRuntimeCall(nme.anyValClass, List(qual, typer.resolveErasureTag(qual.tpe.widen, tree.pos, true)))) else tree diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index cf00ee6b5d..ef98935f9c 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -410,23 +410,23 @@ abstract class UnCurry extends InfoTransform def sequenceToArray(tree: Tree) = { val toArraySym = tree.tpe member nme.toArray assert(toArraySym != NoSymbol) - def getClassTag(tp: Type): Tree = { - val tag = localTyper.resolveArrayTag(tree.pos, tp) + def getArrayTag(tp: Type): Tree = { + val tag = localTyper.resolveArrayTag(tp, tree.pos) // Don't want bottom types getting any further than this (SI-4024) - if (tp.typeSymbol.isBottomClass) getClassTag(AnyClass.tpe) + if (tp.typeSymbol.isBottomClass) getArrayTag(AnyClass.tpe) else if (!tag.isEmpty) tag - else if (tp.bounds.hi ne tp) getClassTag(tp.bounds.hi) - else localTyper.TyperErrorGen.MissingClassTagError(tree, tp) + else if (tp.bounds.hi ne tp) getArrayTag(tp.bounds.hi) + else localTyper.TyperErrorGen.MissingArrayTagError(tree, tp) } - def traversableClassTag(tpe: Type): Tree = { + def traversableArrayTag(tpe: Type): Tree = { (tpe baseType TraversableClass).typeArgs match { - case targ :: _ => getClassTag(targ) + case targ :: _ => getArrayTag(targ) case _ => EmptyTree } } afterUncurry { localTyper.typedPos(pos) { - gen.mkMethodCall(tree, toArraySym, Nil, List(traversableClassTag(tree.tpe))) + gen.mkMethodCall(tree, toArraySym, Nil, List(traversableArrayTag(tree.tpe))) } } } diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 6932030fc2..08bf581256 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -343,7 +343,7 @@ trait ContextErrors { issueNormalTypeError(tree, "macros cannot be eta-expanded") setError(tree) } - + def MacroPartialApplicationError(tree: Tree) = { issueNormalTypeError(tree, "macros cannot be partially applied") setError(tree) @@ -592,9 +592,9 @@ trait ContextErrors { def AbstractExistentiallyOverParamerizedTpeError(tree: Tree, tp: Type) = issueNormalTypeError(tree, "can't existentially abstract over parameterized type " + tp) - // classTagTree - def MissingClassTagError(tree: Tree, tp: Type) = { - issueNormalTypeError(tree, "cannot find class tag for element type "+tp) + // resolveArrayTag + def MissingArrayTagError(tree: Tree, tp: Type) = { + issueNormalTypeError(tree, "cannot find array tag for element type "+tp) setError(tree) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 787d7af136..722440349a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1266,8 +1266,8 @@ trait Implicits { } val tagInScope = - if (full) context.withMacrosDisabled(resolveTypeTag(pos, ReflectMirrorPrefix.tpe, tp, true)) - else context.withMacrosDisabled(resolveArrayTag(pos, tp)) + if (full) context.withMacrosDisabled(resolveTypeTag(ReflectMirrorPrefix.tpe, tp, pos, true)) + else context.withMacrosDisabled(resolveArrayTag(tp, pos)) if (tagInScope.isEmpty) mot(tp, Nil, Nil) else { val interop = diff --git a/src/compiler/scala/tools/nsc/typechecker/Taggings.scala b/src/compiler/scala/tools/nsc/typechecker/Taggings.scala index d276b39f16..fb0d6fb3c5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Taggings.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Taggings.scala @@ -10,7 +10,7 @@ trait Taggings { trait Tagging { self: Typer => - private def resolveTag(pos: Position, taggedTp: Type) = beforeTyper { + private def resolveTag(taggedTp: Type, pos: Position) = beforeTyper { inferImplicit( EmptyTree, taggedTp, @@ -25,47 +25,47 @@ trait Taggings { /** Finds in scope or materializes an ArrayTag. * Should be used instead of ClassTag or ClassManifest every time compiler needs to create an array. * + * @param tp Type we're looking an ArrayTag for, e.g. resolveArrayTag(IntClass.tpe, pos) will look for ArrayTag[Int]. * @param pos Position for error reporting. Please, provide meaningful value. - * @param tp Type we're looking an ArrayTag for, e.g. resolveArrayTag(pos, IntClass.tpe) will look for ArrayTag[Int]. * * @returns Tree that represents an `scala.reflect.ArrayTag` for `tp` if everything is okay. * EmptyTree if the result contains unresolved (i.e. not spliced) type parameters and abstract type members. */ - def resolveArrayTag(pos: Position, tp: Type): Tree = { + def resolveArrayTag(tp: Type, pos: Position): Tree = { val taggedTp = appliedType(ArrayTagClass.typeConstructor, List(tp)) - resolveTag(pos, taggedTp) + resolveTag(taggedTp, pos) } /** Finds in scope or materializes an ErasureTag (if `concrete` is false) or a ClassTag (if `concrete` is true). * Should be used instead of ClassTag or ClassManifest every time compiler needs to persist an erasure. * + * @param tp Type we're looking an ErasureTag for, e.g. resolveErasureTag(IntClass.tpe, pos, true) will look for ClassTag[Int]. * @param pos Position for error reporting. Please, provide meaningful value. - * @param tp Type we're looking an ErasureTag for, e.g. resolveErasureTag(pos, IntClass.tpe, true) will look for ClassTag[Int]. * @param concrete If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. * If false then the function will always succeed (abstract types will be erased to their upper bounds). * * @returns Tree that represents an `scala.reflect.ErasureTag` for `tp` if everything is okay. * EmptyTree if `concrete` is true and the result contains unresolved (i.e. not spliced) type parameters and abstract type members. */ - def resolveErasureTag(pos: Position, tp: Type, concrete: Boolean): Tree = { + def resolveErasureTag(tp: Type, pos: Position, concrete: Boolean): Tree = { val taggedTp = appliedType(if (concrete) ClassTagClass.typeConstructor else ErasureTagClass.typeConstructor, List(tp)) - resolveTag(pos, taggedTp) + resolveTag(taggedTp, pos) } /** Finds in scope or materializes a TypeTag (if `concrete` is false) or a ConcreteTypeTag (if `concrete` is true). * - * @param pos Position for error reporting. Please, provide meaningful value. * @param pre Prefix that represents a universe this type tag will be bound to. - * @param tp Type we're looking a TypeTag for, e.g. resolveTypeTag(pos, reflectMirrorPrefix, IntClass.tpe, false) will look for scala.reflect.mirror.TypeTag[Int]. + * @param tp Type we're looking a TypeTag for, e.g. resolveTypeTag(reflectMirrorPrefix, IntClass.tpe, pos, false) will look for scala.reflect.mirror.TypeTag[Int]. + * @param pos Position for error reporting. Please, provide meaningful value. * @param concrete If true then the result must not contain unresolved (i.e. not spliced) type parameters and abstract type members. * If false then the function will always succeed (abstract types will be reified as free types). * * @returns Tree that represents a `scala.reflect.TypeTag` for `tp` if everything is okay. * EmptyTree if `concrete` is true and the result contains unresolved (i.e. not spliced) type parameters and abstract type members. */ - def resolveTypeTag(pos: Position, pre: Type, tp: Type, concrete: Boolean): Tree = { + def resolveTypeTag(pre: Type, tp: Type, pos: Position, concrete: Boolean): Tree = { val taggedTp = appliedType(singleType(pre, pre member (if (concrete) ConcreteTypeTagClass else TypeTagClass).name), List(tp)) - resolveTag(pos, taggedTp) + resolveTag(taggedTp, pos) } } }
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 5902e480a3..8c2eae1c86 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -4841,8 +4841,8 @@ trait Typers extends Modes with Adaptations with Taggings { val Some((level, componentType)) = erasure.GenericArray.unapply(tpt.tpe) val tagType = List.iterate(componentType, level)(tpe => appliedType(ArrayClass.asType, List(tpe))).last val newArrayApp = atPos(tree.pos) { - val tag = resolveArrayTag(tree.pos, tagType) - if (tag.isEmpty) MissingClassTagError(tree, tagType) + val tag = resolveArrayTag(tagType, tree.pos) + if (tag.isEmpty) MissingArrayTagError(tree, tagType) else new ApplyToImplicitArgs(Select(tag, nme.newArray), args) } typed(newArrayApp, mode, pt) diff --git a/src/library/scala/collection/GenIterableLike.scala b/src/library/scala/collection/GenIterableLike.scala index 79113ddaa7..290a3b26b5 100644 --- a/src/library/scala/collection/GenIterableLike.scala +++ b/src/library/scala/collection/GenIterableLike.scala @@ -141,7 +141,4 @@ trait GenIterableLike[+A, +Repr] extends Any with GenTraversableLike[A, Repr] { */ def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CBF[Repr, (A1, B), That]): That - def isEmpty = iterator.isEmpty - - def head = iterator.next } diff --git a/src/library/scala/collection/GenTraversableLike.scala b/src/library/scala/collection/GenTraversableLike.scala index 903594b69d..df652f99d9 100644 --- a/src/library/scala/collection/GenTraversableLike.scala +++ b/src/library/scala/collection/GenTraversableLike.scala @@ -59,12 +59,24 @@ trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with def size: Int + /** Selects the first element of this $coll. + * $orderDependent + * @return the first element of this $coll. + * @throws `NoSuchElementException` if the $coll is empty. + */ def head: A - + + /** Optionally selects the first element. + * $orderDependent + * @return the first element of this $coll if it is nonempty, + * `None` if it is empty. + */ + def headOption: Option[A] + /** Tests whether this $coll can be repeatedly traversed. * @return `true` */ - final def isTraversableAgain = true + def isTraversableAgain: Boolean /** Selects all elements except the first. * $orderDependent @@ -72,11 +84,30 @@ trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with * except the first one. * @throws `UnsupportedOperationException` if the $coll is empty. */ - def tail: Repr = { - if (isEmpty) throw new UnsupportedOperationException("empty.tail") - drop(1) - } + def tail: Repr + /** Selects the last element. + * $orderDependent + * @return The last element of this $coll. + * @throws NoSuchElementException If the $coll is empty. + */ + def last: A + + /** Optionally selects the last element. + * $orderDependent + * @return the last element of this $coll$ if it is nonempty, + * `None` if it is empty. + */ + def lastOption: Option[A] + + /** Selects all elements except the last. + * $orderDependent + * @return a $coll consisting of all elements of this $coll + * except the last one. + * @throws `UnsupportedOperationException` if the $coll is empty. + */ + def init: Repr + /** Computes a prefix scan of the elements of the collection. * * Note: The neutral element `z` may be applied more than once. diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index 3ca4bfeee9..3716a318d9 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -84,6 +84,8 @@ trait TraversableLike[+A, +Repr] extends Any */ def repr: Repr = this.asInstanceOf[Repr] + final def isTraversableAgain: Boolean = true + /** The underlying collection seen as an instance of `$Coll`. * By default this is implemented as the current collection object itself, * but this can be overridden. diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala index 014b9b1a42..4cb229fc0f 100644 --- a/src/library/scala/collection/parallel/ParIterableLike.scala +++ b/src/library/scala/collection/parallel/ParIterableLike.scala @@ -178,10 +178,30 @@ self: ParIterableLike[T, Repr, Sequential] => def repr: Repr = this.asInstanceOf[Repr] + final def isTraversableAgain = true + def hasDefiniteSize = true + def isEmpty = size == 0 + def nonEmpty = size != 0 - + + def head = iterator.next + + def headOption = if (nonEmpty) Some(head) else None + + def tail = drop(1) + + def last = { + var lst = head + for (x <- this.seq) lst = x + lst + } + + def lastOption = if (nonEmpty) Some(last) else None + + def init = take(size - 1) + /** Creates a new parallel iterator used to traverse the elements of this parallel collection. * This iterator is more specific than the iterator of the returned by `iterator`, and augmented * with additional accessor and transformer methods. |