Merge pull request #2285 from vigdorchik/silence_scaladoc

Remove unrecognized doc comments

7 files changed, 32 insertions, 32 deletions

diff --git a/src/reflect/scala/reflect/internal/ClassfileConstants.scala b/src/reflect/scala/reflect/internal/ClassfileConstants.scala
index 2ab3caa19d..78f7438429 100644
--- a/src/reflect/scala/reflect/internal/ClassfileConstants.scala
+++ b/src/reflect/scala/reflect/internal/ClassfileConstants.scala
@@ -350,7 +350,7 @@ object ClassfileConstants {
     }
     private def translateFlags(jflags: Int, baseFlags: Long): Long = {
       var res: Long = JAVA | baseFlags
-      /** fast, elegant, maintainable, pick any two... */
+      /* fast, elegant, maintainable, pick any two... */
       res |= translateFlag(jflags & JAVA_ACC_PRIVATE)
       res |= translateFlag(jflags & JAVA_ACC_PROTECTED)
       res |= translateFlag(jflags & JAVA_ACC_FINAL)
diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala
index d9f1d90b62..63178d0b39 100644
--- a/src/reflect/scala/reflect/internal/Mirrors.scala
+++ b/src/reflect/scala/reflect/internal/Mirrors.scala
@@ -197,8 +197,8 @@ trait Mirrors extends api.Mirrors {
     /************************ helpers ************************/
 
     def erasureName[T: ClassTag] : String = {
-      /** We'd like the String representation to be a valid
-       *  scala type, so we have to decode the jvm's secret language.
+      /* We'd like the String representation to be a valid
+       * scala type, so we have to decode the jvm's secret language.
        */
       def erasureString(clazz: Class[_]): String = {
         if (clazz.isArray) "Array[" + erasureString(clazz.getComponentType) + "]"
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index a678edbe01..d7ff4faa5d 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -2825,10 +2825,10 @@ trait Types
        *  See SI-5359.
        */
       val bounds  = tparam.info.bounds
-      /** We can seed the type constraint with the type parameter
-       *  bounds as long as the types are concrete.  This should lower
-       *  the complexity of the search even if it doesn't improve
-       *  any results.
+      /* We can seed the type constraint with the type parameter
+       * bounds as long as the types are concrete.  This should lower
+       * the complexity of the search even if it doesn't improve
+       * any results.
        */
       if (propagateParameterBoundsToTypeVars) {
         val exclude = bounds.isEmptyBounds || (bounds exists typeIsNonClassType)
@@ -3533,7 +3533,7 @@ trait Types
     if (args.isEmpty)
       return tycon //@M! `if (args.isEmpty) tycon' is crucial (otherwise we create new types in phases after typer and then they don't get adapted (??))
 
-    /** Disabled - causes cycles in tcpoly tests. */
+    /* Disabled - causes cycles in tcpoly tests. */
     if (false && isDefinitionsInitialized) {
       assert(isUseableAsTypeArgs(args), {
         val tapp_s = s"""$tycon[${args mkString ", "}]"""
@@ -4596,7 +4596,7 @@ object TypesStats {
   val singletonBaseTypeSeqCount = Statistics.newSubCounter("  of which for singletons", baseTypeSeqCount)
   val typeOpsStack = Statistics.newTimerStack()
 
-  /** Commented out, because right now this does not inline, so creates a closure which will distort statistics
+  /* Commented out, because right now this does not inline, so creates a closure which will distort statistics
   @inline final def timedTypeOp[T](c: Statistics.StackableTimer)(op: => T): T = {
     val start = Statistics.pushTimer(typeOpsStack, c)
     try op
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 3850f965b0..c940d863f7 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -516,18 +516,18 @@ abstract class UnPickler {
       var mods: Modifiers = null
       var name: Name = null
 
-      /** Read a Symbol, Modifiers, and a Name */
+      /* Read a Symbol, Modifiers, and a Name */
       def setSymModsName() {
         symbol = readSymbolRef()
         mods = readModifiersRef()
         name = readNameRef()
       }
-      /** Read a Symbol and a Name */
+      /* Read a Symbol and a Name */
       def setSymName() {
         symbol = readSymbolRef()
         name = readNameRef()
       }
-      /** Read a Symbol */
+      /* Read a Symbol */
       def setSym() {
         symbol = readSymbolRef()
       }
diff --git a/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala b/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
index d36aa0c927..e9d3ffbf56 100644
--- a/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
+++ b/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
@@ -396,11 +396,11 @@ trait TypeComparers {
     if (isSingleType(tp1) && isSingleType(tp2) || isConstantType(tp1) && isConstantType(tp2)) return tp1 =:= tp2
     if (tp1.isHigherKinded || tp2.isHigherKinded) return isHKSubType(tp1, tp2, depth)
 
-    /** First try, on the right:
-      *   - unwrap Annotated types, BoundedWildcardTypes,
-      *   - bind TypeVars  on the right, if lhs is not Annotated nor BoundedWildcard
-      *   - handle common cases for first-kind TypeRefs on both sides as a fast path.
-      */
+    /* First try, on the right:
+     *   - unwrap Annotated types, BoundedWildcardTypes,
+     *   - bind TypeVars  on the right, if lhs is not Annotated nor BoundedWildcard
+     *   - handle common cases for first-kind TypeRefs on both sides as a fast path.
+     */
     def firstTry = tp2 match {
       // fast path: two typerefs, none of them HK
       case tr2: TypeRef =>
@@ -445,11 +445,11 @@ trait TypeComparers {
         secondTry
     }
 
-    /** Second try, on the left:
-      *   - unwrap AnnotatedTypes, BoundedWildcardTypes,
-      *   - bind typevars,
-      *   - handle existential types by skolemization.
-      */
+    /* Second try, on the left:
+     *   - unwrap AnnotatedTypes, BoundedWildcardTypes,
+     *   - bind typevars,
+     *   - handle existential types by skolemization.
+     */
     def secondTry = tp1 match {
       case AnnotatedType(_, _, _) =>
         isSubType(tp1.withoutAnnotations, tp2.withoutAnnotations, depth) &&
@@ -487,11 +487,11 @@ trait TypeComparers {
       }
     }
 
-    /** Third try, on the right:
-      *   - decompose refined types.
-      *   - handle typerefs and existentials.
-      *   - handle left+right method types, polytypes, typebounds
-      */
+    /* Third try, on the right:
+     *   - decompose refined types.
+     *   - handle typerefs and existentials.
+     *   - handle left+right method types, polytypes, typebounds
+     */
     def thirdTry = tp2 match {
       case tr2: TypeRef =>
         thirdTryRef(tp1, tr2)
@@ -532,9 +532,9 @@ trait TypeComparers {
         fourthTry
     }
 
-    /** Fourth try, on the left:
-      *   - handle typerefs, refined types, and singleton types.
-      */
+    /* Fourth try, on the left:
+     *   - handle typerefs, refined types, and singleton types.
+     */
     def fourthTry = {
       def retry(lhs: Type, rhs: Type)  = isSubType(lhs, rhs, depth)
       def abstractTypeOnLeft(hi: Type) = isDifferentTypeConstructor(tp1, hi) && retry(hi, tp2)
diff --git a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala
index d225f2f087..0f9db31ec1 100644
--- a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala
+++ b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala
@@ -1033,7 +1033,7 @@ private[internal] trait TypeMaps {
           devWarning(s"$pre.$sym no longer exist at phase $phase")
           throw new MissingTypeControl // For build manager and presentation compiler purposes
         }
-        /** The two symbols have the same fully qualified name */
+        /* The two symbols have the same fully qualified name */
         def corresponds(sym1: Symbol, sym2: Symbol): Boolean =
           sym1.name == sym2.name && (sym1.isPackageClass || corresponds(sym1.owner, sym2.owner))
         if (!corresponds(sym.owner, rebind0.owner)) {
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index c5c28ad3e9..2e38caaf5d 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -60,7 +60,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
 
   /** The API of a mirror for a reflective universe */
   class JavaMirror(owner: Symbol,
-    /** Class loader that is a mastermind behind the reflexive mirror */
+    /* Class loader that is a mastermind behind the reflexive mirror */
     val classLoader: ClassLoader
   ) extends Roots(owner) with super.JavaMirror { thisMirror =>