Merge remote-tracking branch 'origin/2.11.x' into merge/2.11.x-to-2.12.x-20150129

Conflicts:
	build.number
	src/library/scala/concurrent/Future.scala
	versions.properties

27 files changed, 54 insertions, 46 deletions

diff --git a/src/reflect/scala/reflect/api/Liftables.scala b/src/reflect/scala/reflect/api/Liftables.scala
index 673dbce6f5..c6352905d1 100644
--- a/src/reflect/scala/reflect/api/Liftables.scala
+++ b/src/reflect/scala/reflect/api/Liftables.scala
@@ -52,7 +52,7 @@ trait Liftables { self: Universe =>
   object Unliftable extends StandardUnliftableInstances {
     /** A helper method that simplifies creation of `Unliftable` instances.
      *  Takes a partial function which is defined on correct representations of `T`
-     *  and returns corresponing instances.
+     *  and returns corresponding instances.
      *
      *  For example to extract a reference to an object as object itself:
      *
diff --git a/src/reflect/scala/reflect/api/Mirrors.scala b/src/reflect/scala/reflect/api/Mirrors.scala
index 773c6b6fb4..adaf829b32 100644
--- a/src/reflect/scala/reflect/api/Mirrors.scala
+++ b/src/reflect/scala/reflect/api/Mirrors.scala
@@ -338,7 +338,7 @@ trait Mirrors { self: Universe =>
      *  with getting a field or invoking a getter method of the field.
      *
      *  If `symbol` represents a field of a base class with respect to the class of the receiver,
-     *  and this base field is overriden in the class of the receiver, then this method will retrieve
+     *  and this base field is overridden in the class of the receiver, then this method will retrieve
      *  the value of the base field. To achieve overriding behavior, use reflectMethod on an accessor.
      */
     def get: Any
@@ -352,7 +352,7 @@ trait Mirrors { self: Universe =>
      *  with setting a field or invoking a setter method of the field.
      *
      *  If `symbol` represents a field of a base class with respect to the class of the receiver,
-     *  and this base field is overriden in the class of the receiver, then this method will set
+     *  and this base field is overridden in the class of the receiver, then this method will set
      *  the value of the base field. To achieve overriding behavior, use reflectMethod on an accessor.
      */
     def set(value: Any): Unit
diff --git a/src/reflect/scala/reflect/api/Names.scala b/src/reflect/scala/reflect/api/Names.scala
index 03f7b2d218..472da60338 100644
--- a/src/reflect/scala/reflect/api/Names.scala
+++ b/src/reflect/scala/reflect/api/Names.scala
@@ -72,10 +72,10 @@ trait Names {
    *  @group API
    */
   abstract class NameApi {
-    /** Checks wether the name is a term name */
+    /** Checks whether the name is a term name */
     def isTermName: Boolean
 
-    /** Checks wether the name is a type name */
+    /** Checks whether the name is a type name */
     def isTypeName: Boolean
 
     /** Returns a term name that wraps the same string as `this` */
diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala
index 18d185067e..c01029d067 100644
--- a/src/reflect/scala/reflect/api/Symbols.scala
+++ b/src/reflect/scala/reflect/api/Symbols.scala
@@ -339,7 +339,7 @@ trait Symbols { self: Universe =>
     @deprecated("Use `overrides` instead", "2.11.0")
     def allOverriddenSymbols: List[Symbol]
 
-    /** Returns all symbols overriden by this symbol.
+    /** Returns all symbols overridden by this symbol.
      *
      *  @group Basics
      */
diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala
index aeaa38c317..9ecd87c17e 100644
--- a/src/reflect/scala/reflect/api/Trees.scala
+++ b/src/reflect/scala/reflect/api/Trees.scala
@@ -158,7 +158,7 @@ trait Trees { self: Universe =>
     /** Do all parts of this tree satisfy predicate `p`? */
     def forAll(p: Tree => Boolean): Boolean
 
-    /** Tests whether two trees are structurall equal.
+    /** Tests whether two trees are structurally equal.
      *  Note that `==` on trees is reference equality.
      */
     def equalsStructure(that : Tree): Boolean
diff --git a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
index 0ca8611719..54f64153c1 100644
--- a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
+++ b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
@@ -144,7 +144,7 @@ trait BaseTypeSeqs {
         "\n --- because ---\n"+msg)
   }
 
-  /** A merker object for a base type sequence that's no yet computed.
+  /** A marker object for a base type sequence that's no yet computed.
    *  used to catch inheritance cycles
    */
   val undetBaseTypeSeq: BaseTypeSeq = newBaseTypeSeq(List(), Array())
@@ -152,7 +152,7 @@ trait BaseTypeSeqs {
   /** Create a base type sequence consisting of a single type */
   def baseTypeSingletonSeq(tp: Type): BaseTypeSeq = newBaseTypeSeq(List(), Array(tp))
 
-  /** Create the base type sequence of a compound type wuth given tp.parents */
+  /** Create the base type sequence of a compound type with given tp.parents */
   def compoundBaseTypeSeq(tp: Type): BaseTypeSeq = {
     val tsym = tp.typeSymbol
     val parents = tp.parents
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 7e2d124486..9f4ec3e6d1 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -514,6 +514,8 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ScalaSignatureAnnotation = requiredClass[scala.reflect.ScalaSignature]
     lazy val ScalaLongSignatureAnnotation = requiredClass[scala.reflect.ScalaLongSignature]
 
+    lazy val MethodHandle = getClassIfDefined("java.lang.invoke.MethodHandle")
+
     // Option classes
     lazy val OptionClass: ClassSymbol   = requiredClass[Option[_]]
     lazy val OptionModule: ModuleSymbol = requiredModule[scala.Option.type]
@@ -931,7 +933,7 @@ trait Definitions extends api.StandardDefinitions {
 
     // members of class scala.Any
 
-    // TODO these aren't final! They are now overriden in AnyRef/Object. Prior to the fix
+    // TODO these aren't final! They are now overridden in AnyRef/Object. Prior to the fix
     //      for SI-8129, they were actually *overloaded* by the members in AnyRef/Object.
     //      We should unfinalize these, override in AnyValClass, and make the overrides final.
     //      Refchecks never actually looks at these, so its just for consistency.
@@ -1508,6 +1510,9 @@ trait Definitions extends api.StandardDefinitions {
 
       lazy val PartialManifestClass  = getTypeMember(ReflectPackage, tpnme.ClassManifest)
       lazy val ManifestSymbols = Set[Symbol](PartialManifestClass, FullManifestClass, OptManifestClass)
+
+      def isPolymorphicSignature(sym: Symbol) = PolySigMethods(sym)
+      private lazy val PolySigMethods: Set[Symbol] = Set[Symbol](MethodHandle.info.decl(sn.Invoke), MethodHandle.info.decl(sn.InvokeExact)).filter(_.exists)
     }
   }
 }
diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala
index 2fca99aff9..0f0f16574e 100644
--- a/src/reflect/scala/reflect/internal/Mirrors.scala
+++ b/src/reflect/scala/reflect/internal/Mirrors.scala
@@ -268,7 +268,7 @@ trait Mirrors extends api.Mirrors {
 
     // TODO - having these as objects means they elude the attempt to
     // add synchronization in SynchronizedSymbols.  But we should either
-    // flip on object overrides or find some other accomodation, because
+    // flip on object overrides or find some other accommodation, because
     // lazy vals are unnecessarily expensive relative to objects and it
     // is very beneficial for a handful of bootstrap symbols to have
     // first class identities
diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala
index b50f324074..32d12d305e 100644
--- a/src/reflect/scala/reflect/internal/Names.scala
+++ b/src/reflect/scala/reflect/internal/Names.scala
@@ -131,11 +131,11 @@ trait Names extends api.Names {
     newTermName(cs, offset, len, cachedString).toTypeName
 
   /** Create a term name from string. */
-  @deprecatedOverriding("To synchronize, use `override def synchronizeNames = true`", "2.11.0") // overriden in https://github.com/scala-ide/scala-ide/blob/master/org.scala-ide.sdt.core/src/scala/tools/eclipse/ScalaPresentationCompiler.scala
+  @deprecatedOverriding("To synchronize, use `override def synchronizeNames = true`", "2.11.0") // overridden in https://github.com/scala-ide/scala-ide/blob/master/org.scala-ide.sdt.core/src/scala/tools/eclipse/ScalaPresentationCompiler.scala
   def newTermName(s: String): TermName = newTermName(s.toCharArray(), 0, s.length(), null)
 
   /** Create a type name from string. */
-  @deprecatedOverriding("To synchronize, use `override def synchronizeNames = true`", "2.11.0") // overriden in https://github.com/scala-ide/scala-ide/blob/master/org.scala-ide.sdt.core/src/scala/tools/eclipse/ScalaPresentationCompiler.scala
+  @deprecatedOverriding("To synchronize, use `override def synchronizeNames = true`", "2.11.0") // overridden in https://github.com/scala-ide/scala-ide/blob/master/org.scala-ide.sdt.core/src/scala/tools/eclipse/ScalaPresentationCompiler.scala
   def newTypeName(s: String): TypeName = newTermName(s).toTypeName
 
   /** Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1]. */
diff --git a/src/reflect/scala/reflect/internal/Positions.scala b/src/reflect/scala/reflect/internal/Positions.scala
index c16d8778d9..4d0e31b037 100644
--- a/src/reflect/scala/reflect/internal/Positions.scala
+++ b/src/reflect/scala/reflect/internal/Positions.scala
@@ -204,7 +204,7 @@ trait Positions extends api.Positions { self: SymbolTable =>
   /** Set position of all children of a node
    *  @param  pos   A target position.
    *                Uses the point of the position as the point of all positions it assigns.
-   *                Uses the start of this position as an Offset position for unpositioed trees
+   *                Uses the start of this position as an Offset position for unpositioned trees
    *                without children.
    *  @param  trees  The children to position. All children must be positionable.
    */
diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index c4953b2c1f..98b2c48379 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -546,10 +546,11 @@ trait Printers extends api.Printers { self: SymbolTable =>
       import Chars._
       val decName = name.decoded
       val bslash = '\\'
+      val isDot = (x: Char) => x == '.'
       val brackets = List('[',']','(',')','{','}')
 
       def addBackquotes(s: String) =
-        if (decoded && (decName.exists(ch => brackets.contains(ch) || isWhitespace(ch)) ||
+        if (decoded && (decName.exists(ch => brackets.contains(ch) || isWhitespace(ch) || isDot(ch)) ||
           (name.isOperatorName && decName.exists(isOperatorPart) && decName.exists(isScalaLetter) && !decName.contains(bslash))))
           s"`$s`" else s
 
diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala
index 614e71b597..cca33253be 100644
--- a/src/reflect/scala/reflect/internal/StdAttachments.scala
+++ b/src/reflect/scala/reflect/internal/StdAttachments.scala
@@ -27,7 +27,7 @@ trait StdAttachments {
     def importAttachment(importer: Importer): this.type
   }
 
-  /** Attachment that doesn't contain any reflection artificats and can be imported as-is. */
+  /** Attachment that doesn't contain any reflection artifacts and can be imported as-is. */
   trait PlainAttachment extends ImportableAttachment {
     def importAttachment(importer: Importer): this.type = this
   }
@@ -42,7 +42,7 @@ trait StdAttachments {
    */
   case object BackquotedIdentifierAttachment extends PlainAttachment
 
-  /** Identifies trees are either result or intermidiate value of for loop desugaring.
+  /** Identifies trees are either result or intermediate value of for loop desugaring.
    */
   case object ForAttachment extends PlainAttachment
 
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index b7e2886340..ea07fb2a74 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -1148,6 +1148,7 @@ trait StdNames {
     final val GetClassLoader: TermName   = newTermName("getClassLoader")
     final val GetMethod: TermName        = newTermName("getMethod")
     final val Invoke: TermName           = newTermName("invoke")
+    final val InvokeExact: TermName      = newTermName("invokeExact")
 
     val Boxed = immutable.Map[TypeName, TypeName](
       tpnme.Boolean -> BoxedBoolean,
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index d32af88a36..f2aa14b866 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -682,7 +682,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  to fix the core of the compiler risk stability a few weeks before the final release.
      *  upd. Haha, "a few weeks before the final release". This surely sounds familiar :)
      *
-     *  However we do need to fix this for runtime reflection, since this idionsynchrazy is not something
+     *  However we do need to fix this for runtime reflection, since this idiosyncrasy is not something
      *  we'd like to expose to reflection users. Therefore a proposed solution is to check whether we're in a
      *  runtime reflection universe, and if yes and if we've not yet loaded the requested info, then to commence initialization.
      */
@@ -740,7 +740,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *
      * Note: the lateMETHOD flag is added lazily in the info transformer of the RefChecks phase.
      * This means that forcing the `sym.info` may change the value of `sym.isMethod`. Forcing the
-     * info is in the responsability of the caller. Doing it eagerly here was tried (0ccdb151f) but
+     * info is in the responsibility of the caller. Doing it eagerly here was tried (0ccdb151f) but
      * has proven to lead to bugs (SI-8907).
      *
      * Here's an example where one can see all four of FF FT TF TT for (isStatic, isMethod) at
@@ -2818,7 +2818,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     override def outerSource: Symbol =
       // SI-6888 Approximate the name to workaround the deficiencies in `nme.originalName`
-      //         in the face of clases named '$'. SI-2806 remains open to address the deeper problem.
+      //         in the face of classes named '$'. SI-2806 remains open to address the deeper problem.
       if (originalName endsWith (nme.OUTER)) initialize.referenced
       else NoSymbol
 
@@ -3572,7 +3572,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
    *  @param    syms    the prototypical symbols
    *  @param    symFn   the function to create new symbols
    *  @param    tpe     the prototypical type
-   *  @return           the new symbol-subsituted type
+   *  @return           the new symbol-substituted type
    */
   def deriveType(syms: List[Symbol], symFn: Symbol => Symbol)(tpe: Type): Type = {
     val syms1 = deriveSymbols(syms, symFn)
@@ -3587,7 +3587,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
    *  @param    as      arguments to be passed to symFn together with symbols from syms (must be same length)
    *  @param    symFn   the function to create new symbols based on `as`
    *  @param    tpe     the prototypical type
-   *  @return           the new symbol-subsituted type
+   *  @return           the new symbol-substituted type
    */
   def deriveType2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) => Symbol)(tpe: Type): Type = {
     val syms1 = deriveSymbols2(syms, as, symFn)
diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala
index 6ddd49045c..4cedfe2665 100644
--- a/src/reflect/scala/reflect/internal/TreeGen.scala
+++ b/src/reflect/scala/reflect/internal/TreeGen.scala
@@ -713,7 +713,7 @@ abstract class TreeGen {
 
       val rhsUnchecked = mkUnchecked(rhs)
 
-      // TODO: clean this up -- there is too much information packked into mkPatDef's `pat` argument
+      // TODO: clean this up -- there is too much information packed into mkPatDef's `pat` argument
       // when it's a simple identifier (case Some((name, tpt)) -- above),
       // pat should have the type ascription that was specified by the user
       // however, in `case None` (here), we must be careful not to generate illegal pattern trees (such as `(a, b): Tuple2[Int, String]`)
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index c521277f69..4657fa0000 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -588,7 +588,7 @@ abstract class TreeInfo {
 
   private def hasNoSymbol(t: Tree) = t.symbol == null || t.symbol == NoSymbol
 
-  /** Is this pattern node a synthetic catch-all case, added during PartialFuction synthesis before we know
+  /** Is this pattern node a synthetic catch-all case, added during PartialFunction synthesis before we know
     * whether the user provided cases are exhaustive. */
   def isSyntheticDefaultCase(cdef: CaseDef) = cdef match {
     case CaseDef(Bind(nme.DEFAULT_CASE, _), EmptyTree, _) => true
@@ -815,7 +815,7 @@ abstract class TreeInfo {
   object Unapplied {
     // Duplicated with `spliceApply`
     def unapply(tree: Tree): Option[Tree] = tree match {
-      // SI-7868 Admit Select() to account for numeric widening, e.g. <unappplySelector>.toInt
+      // SI-7868 Admit Select() to account for numeric widening, e.g. <unapplySelector>.toInt
       case Apply(fun, (Ident(nme.SELECTOR_DUMMY)| Select(Ident(nme.SELECTOR_DUMMY), _)) :: Nil)
                          => Some(fun)
       case Apply(fun, _) => unapply(fun)
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 325de013d7..4d230cc1cc 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -738,7 +738,7 @@ trait Types
      * `substThis(from, to).substSym(symsFrom, symsTo)`.
      *
      * `SubstThisAndSymMap` performs a breadth-first map over this type, which meant that
-     * symbol substitution occured before `ThisType` substitution. Consequently, in substitution
+     * symbol substitution occurred before `ThisType` substitution. Consequently, in substitution
      * of a `SingleType(ThisType(`from`), sym), symbols were rebound to `from` rather than `to`.
      */
     def substThisAndSym(from: Symbol, to: Type, symsFrom: List[Symbol], symsTo: List[Symbol]): Type =
@@ -1701,7 +1701,7 @@ trait Types
      */
     private var refs: Array[RefMap] = _
 
-    /** The initialization state of the class: UnInialized --> Initializing --> Initialized
+    /** The initialization state of the class: UnInitialized --> Initializing --> Initialized
      *  Syncnote: This var need not be protected with synchronized, because
      *  it is accessed only from expansiveRefs, which is called only from
      *  Typer.
@@ -1986,7 +1986,7 @@ trait Types
     require(sym.isNonClassType, sym)
 
     /* Syncnote: These are pure caches for performance; no problem to evaluate these
-     * several times. Hence, no need to protected with synchronzied in a mutli-threaded
+     * several times. Hence, no need to protected with synchronized in a multi-threaded
      * usage scenario.
      */
     private var relativeInfoCache: Type = _
@@ -2657,7 +2657,7 @@ trait Types
      *     nowhere inside a type argument
      *   - no quantified type argument contains a quantified variable in its bound
      *   - the typeref's symbol is not itself quantified
-     *   - the prefix is not quanitified
+     *   - the prefix is not quantified
      */
     def isRepresentableWithWildcards = {
       val qset = quantified.toSet
@@ -3115,7 +3115,7 @@ trait Types
       // addressed here: all lower bounds are retained and their intersection calculated when the
       // bounds are solved.
       //
-      // In a side-effect free universe, checking tp and tp.parents beofre checking tp.baseTypeSeq
+      // In a side-effect free universe, checking tp and tp.parents before checking tp.baseTypeSeq
       // would be pointless. In this case, each check we perform causes us to lose specificity: in
       // the end the best we'll do is the least specific type we tested against, since the typevar
       // does not see these checks as "probes" but as requirements to fulfill.
@@ -3346,7 +3346,7 @@ trait Types
    *
    *  SI-6385 Erasure's creation of bridges considers method signatures `exitingErasure`,
    *          which contain `ErasedValueType`-s. In order to correctly consider the overriding
-   *          and overriden signatures as equivalent in `run/t6385.scala`, it is critical that
+   *          and overridden signatures as equivalent in `run/t6385.scala`, it is critical that
    *          this type contains the erasure of the wrapped type, rather than the unerased type
    *          of the value class itself, as was originally done.
    *
diff --git a/src/reflect/scala/reflect/internal/Variances.scala b/src/reflect/scala/reflect/internal/Variances.scala
index 12b765b7a6..ef22df3f2e 100644
--- a/src/reflect/scala/reflect/internal/Variances.scala
+++ b/src/reflect/scala/reflect/internal/Variances.scala
@@ -32,7 +32,7 @@ trait Variances {
 
     /** Is every symbol in the owner chain between `site` and the owner of `sym`
      *  either a term symbol or private[this]? If not, add `sym` to the set of
-     *  esacped locals.
+     *  escaped locals.
      *  @pre  sym.isLocalToThis
      */
     @tailrec final def checkForEscape(sym: Symbol, site: Symbol) {
diff --git a/src/reflect/scala/reflect/internal/annotations/uncheckedBounds.scala b/src/reflect/scala/reflect/internal/annotations/uncheckedBounds.scala
index a44bb54734..662d841c91 100644
--- a/src/reflect/scala/reflect/internal/annotations/uncheckedBounds.scala
+++ b/src/reflect/scala/reflect/internal/annotations/uncheckedBounds.scala
@@ -5,7 +5,7 @@ package annotations
 /**
  * An annotation that designates the annotated type should not be checked for violations of
  * type parameter bounds in the `refchecks` phase of the compiler. This can be used by synthesized
- * code the uses an inferred type of an expression as the type of an artifict val/def (for example,
+ * code the uses an inferred type of an expression as the type of an artifact val/def (for example,
  * a temporary value introduced by an ANF transform). See [[https://issues.scala-lang.org/browse/SI-7694]].
  *
  * @since  2.10.3
diff --git a/src/reflect/scala/reflect/internal/tpe/FindMembers.scala b/src/reflect/scala/reflect/internal/tpe/FindMembers.scala
index de54f3768e..42b13944f6 100644
--- a/src/reflect/scala/reflect/internal/tpe/FindMembers.scala
+++ b/src/reflect/scala/reflect/internal/tpe/FindMembers.scala
@@ -12,7 +12,7 @@ import TypesStats._
 trait FindMembers {
   this: SymbolTable =>
 
-  /** Implementatation of `Type#{findMember, findMembers}` */
+  /** Implementation of `Type#{findMember, findMembers}` */
   private[internal] abstract class FindMemberBase[T](tpe: Type, name: Name, excludedFlags: Long, requiredFlags: Long) {
     protected val initBaseClasses: List[Symbol] = tpe.baseClasses
 
diff --git a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala
index c1c43178e5..f79099213a 100644
--- a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala
+++ b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala
@@ -75,7 +75,7 @@ private[internal] trait TypeConstraints {
     /*  Syncnote: Type constraints are assumed to be used from only one
      *  thread. They are not exposed in api.Types and are used only locally
      *  in operations that are exposed from types. Hence, no syncing of any
-     *  variables should be ncessesary.
+     *  variables should be necessary.
      */
 
     /** Guard these lists against AnyClass and NothingClass appearing,
diff --git a/src/reflect/scala/reflect/internal/util/WeakHashSet.scala b/src/reflect/scala/reflect/internal/util/WeakHashSet.scala
index a9a7c7780d..3a7a7626fb 100644
--- a/src/reflect/scala/reflect/internal/util/WeakHashSet.scala
+++ b/src/reflect/scala/reflect/internal/util/WeakHashSet.scala
@@ -7,13 +7,13 @@ import scala.collection.generic.Clearable
 import scala.collection.mutable.{Set => MSet}
 
 /**
- * A HashSet where the elements are stored weakly. Elements in this set are elligible for GC if no other
+ * A HashSet where the elements are stored weakly. Elements in this set are eligible for GC if no other
  * hard references are associated with them. Its primary use case is as a canonical reference
  * identity holder (aka "hash-consing") via findEntryOrUpdate
  *
  * This Set implementation cannot hold null. Any attempt to put a null in it will result in a NullPointerException
  *
- * This set implmeentation is not in general thread safe without external concurrency control. However it behaves
+ * This set implementation is not in general thread safe without external concurrency control. However it behaves
  * properly when GC concurrently collects elements in this set.
  */
 final class WeakHashSet[A <: AnyRef](val initialCapacity: Int, val loadFactor: Double) extends Set[A] with Function1[A, Boolean] with MSet[A] {
@@ -26,7 +26,7 @@ final class WeakHashSet[A <: AnyRef](val initialCapacity: Int, val loadFactor: D
 
   /**
    * queue of Entries that hold elements scheduled for GC
-   * the removeStaleEntries() method works through the queue to remeove
+   * the removeStaleEntries() method works through the queue to remove
    * stale entries from the table
    */
   private[this] val queue = new ReferenceQueue[A]
@@ -62,7 +62,7 @@ final class WeakHashSet[A <: AnyRef](val initialCapacity: Int, val loadFactor: D
   private[this] def computeThreshHold: Int = (table.size * loadFactor).ceil.toInt
 
   /**
-   * find the bucket associated with an elements's hash code
+   * find the bucket associated with an element's hash code
    */
   private[this] def bucketFor(hash: Int): Int = {
     // spread the bits around to try to avoid accidental collisions using the
diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala
index 69ede42cc7..1eb6832b5b 100644
--- a/src/reflect/scala/reflect/macros/Enclosures.scala
+++ b/src/reflect/scala/reflect/macros/Enclosures.scala
@@ -47,7 +47,7 @@ trait Enclosures {
 
   /** Tries to guess a position for the enclosing application.
    *  But that is simple, right? Just dereference `pos` of `macroApplication`? Not really.
-   *  If we're in a synthetic macro expansion (no positions), we must do our best to infer the position of something that triggerd this expansion.
+   *  If we're in a synthetic macro expansion (no positions), we must do our best to infer the position of something that triggered this expansion.
    *  Surprisingly, quite often we can do this by navigation the `enclosingMacros` stack.
    */
   def enclosingPosition: Position
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index 1eb67215bb..3b57169565 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -44,7 +44,7 @@ abstract class Universe extends scala.reflect.api.Universe {
      *  it is imperative that you either call `untypecheck` or do `changeOwner(tree, x, y)`.
      *
      *  Since at the moment `untypecheck` has fundamental problem that can sometimes lead to tree corruption,
-     *  `changeOwner` becomes an indispensible tool in building 100% robust macros.
+     *  `changeOwner` becomes an indispensable tool in building 100% robust macros.
      *  Future versions of the reflection API might obviate the need in taking care of
      *  these low-level details, but at the moment this is what we've got.
      */
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index a0da3f3bbf..1c751fb93b 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -38,7 +38,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
 
   override lazy val rootMirror: Mirror = createMirror(NoSymbol, rootClassLoader)
 
-  // overriden by ReflectGlobal
+  // overridden by ReflectGlobal
   def rootClassLoader: ClassLoader = this.getClass.getClassLoader
 
   trait JavaClassCompleter
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
index c87b810bdd..1c0aa7cf6d 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
@@ -310,6 +310,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     definitions.QuasiquoteClass_api_unapply
     definitions.ScalaSignatureAnnotation
     definitions.ScalaLongSignatureAnnotation
+    definitions.MethodHandle
     definitions.OptionClass
     definitions.OptionModule
     definitions.SomeClass
diff --git a/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala b/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala
index 6d0cb0df45..4f0c0253e9 100644
--- a/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala
+++ b/src/reflect/scala/reflect/runtime/SynchronizedSymbols.scala
@@ -39,7 +39,7 @@ private[reflect] trait SynchronizedSymbols extends internal.Symbols { self: Symb
      *  Reasons for that differ from artifact to artifact. In some cases it's quite bad (e.g. types use a number
      *  of non-concurrent compiler caches, so we need to serialize certain operations on types in order to make
      *  sure that things stay deterministic). However, in case of symbols there's hope, because it's only during
-     *  initializaton that symbols are thread-unsafe. After everything's set up, symbols become immutable
+     *  initialization that symbols are thread-unsafe. After everything's set up, symbols become immutable
      *  (sans a few deterministic caches that can be populated simultaneously by multiple threads) and therefore thread-safe.
      *
      *  Note that by saying "symbols become immutable" I mean literally that. In a very common case of PackageClassSymbol's,
@@ -102,10 +102,10 @@ private[reflect] trait SynchronizedSymbols extends internal.Symbols { self: Symb
      *
      *  Just a volatile var is fine, because:
      *    1) Status can only be changed in a single-threaded fashion (this is enforced by gilSynchronized
-     *       that effecively guards `Symbol.initialize`), which means that there can't be update conflicts.
+     *       that effectively guards `Symbol.initialize`), which means that there can't be update conflicts.
      *    2) If someone reads a stale value of status, then the worst thing that might happen is that this someone
-     *       is going to spuriously call `initialize`, which is either a gil-protected operation (if the symbol isn't inited yet)
-     *       or a no-op (if the symbol is already inited), and that is fine in both cases.
+     *       is going to spuriously call `initialize`, which is either a gil-protected operation (if the symbol isn't initialized yet)
+     *       or a no-op (if the symbol is already initialized), and that is fine in both cases.
      *
      *  upd. It looks like we also need to keep track of a mask of initialized flags to make sure
      *  that normal symbol initialization routines don't trigger auto-init in Symbol.flags-related routines (e.g. Symbol.getFlag).