Merge pull request #313 from dotty-staging/more-tests

More tests

Author: DarkDimius

src/dotty/tools/dotc/TypeErasure.scala

@@ -160,11 +160,11 @@ object TypeErasure {
    *  as upper bound and that is not Java defined? Arrays of such types are
    *  erased to `Object` instead of `ObjectArray`.
    */
-  def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp match {
+  def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp.dealias match {
     case tp: TypeRef =>
-      tp.symbol.isAbstractType &&
+      !tp.symbol.isClass &&
       !tp.derivesFrom(defn.ObjectClass) &&
-      !tp.typeSymbol.is(JavaDefined)
+      !tp.symbol.is(JavaDefined)
     case tp: PolyParam =>
       !tp.derivesFrom(defn.ObjectClass) &&
       !tp.binder.resultType.isInstanceOf[JavaMethodType]
@@ -342,11 +342,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
   private def eraseArray(tp: RefinedType)(implicit ctx: Context) = {
     val defn.ArrayType(elemtp) = tp
     if (elemtp derivesFrom defn.NullClass) JavaArrayType(defn.ObjectType)
-    else if (isUnboundedGeneric(elemtp))
-      elemtp match {
-        case elemtp: TypeRef if elemtp.symbol.is(JavaDefined) => JavaArrayType(defn.ObjectType)
-        case _ => defn.ObjectType
-      }
+    else if (isUnboundedGeneric(elemtp)) defn.ObjectType
     else JavaArrayType(this(elemtp))
   }
 

src/dotty/tools/dotc/ast/Desugar.scala

@@ -290,8 +290,12 @@ object desugar {
         val caseParams = constrVparamss.head.toArray
         val productElemMeths = for (i <- 0 until arity) yield
           syntheticProperty(nme.selectorName(i), Select(This(EmptyTypeName), caseParams(i).name))
+        val hasRepeatedParam = constrVparamss.exists(_.exists {
+          case ValDef(_, PostfixOp(_, nme.raw.STAR), _) => true
+          case _ => false
+        })
         val copyMeths =
-          if (mods is Abstract) Nil
+          if (mods.is(Abstract) || hasRepeatedParam) Nil  // cannot have default arguments for repeated parameters, hence copy method is not issued
           else {
             def copyDefault(vparam: ValDef) =
               makeAnnotated(defn.UncheckedVarianceAnnot, refOfDef(vparam))

src/dotty/tools/dotc/core/Contexts.scala

@@ -170,7 +170,11 @@ object Contexts {
       if (implicitsCache == null )
         implicitsCache = {
           val implicitRefs: List[TermRef] =
-            if (isClassDefContext) owner.thisType.implicitMembers
+            if (isClassDefContext) 
+              try owner.thisType.implicitMembers
+              catch {
+                case ex: CyclicReference => Nil
+              }
             else if (isImportContext) importInfo.importedImplicits
             else if (isNonEmptyScopeContext) scope.implicitDecls
             else Nil

src/dotty/tools/dotc/core/NameOps.scala

@@ -72,6 +72,7 @@ object NameOps {
     def isSetterName = name endsWith SETTER_SUFFIX
     def isSingletonName = name endsWith SINGLETON_SUFFIX
     def isModuleClassName = name endsWith MODULE_SUFFIX
+    def isAvoidClashName = name endsWith AVOID_CLASH_SUFFIX
     def isImportName = name startsWith IMPORT
     def isFieldName = name endsWith LOCAL_SUFFIX
     def isInheritedName = name.length > 0 && name.head == '(' && name.startsWith(nme.INHERITED)
@@ -129,11 +130,19 @@ object NameOps {
     /** If name ends in module class suffix, drop it */
     def stripModuleClassSuffix: Name =
       if (isModuleClassName) name dropRight MODULE_SUFFIX.length else name
+      
+    /** Append a suffix so that this name does not clash with another name in the same scope */
+    def avoidClashName: TermName = (name ++ AVOID_CLASH_SUFFIX).toTermName
+
+    /** If name ends in "avoid clash" suffix, drop it */
+    def stripAvoidClashSuffix: Name =
+      if (isAvoidClashName) name dropRight AVOID_CLASH_SUFFIX.length else name
 
     /** If flags is a ModuleClass but not a Package, add module class suffix */
-    def adjustIfModuleClass(flags: Flags.FlagSet): N =
-      if (flags is (ModuleClass, butNot = Package)) name.asTypeName.moduleClassName.asInstanceOf[N]
-      else name
+    def adjustIfModuleClass(flags: Flags.FlagSet): N = {
+      if (flags is (ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
+      else stripAvoidClashSuffix
+    }.asInstanceOf[N]
 
     /** The superaccessor for method with given name */
     def superName: TermName =  (nme.SUPER_PREFIX ++ name).toTermName

src/dotty/tools/dotc/core/StdNames.scala

@@ -107,6 +107,7 @@ object StdNames {
     val INTERPRETER_WRAPPER_SUFFIX: N = "$object"
     val LOCALDUMMY_PREFIX: N          = "<local "       // owner of local blocks
     val MODULE_SUFFIX: N              = NameTransformer.MODULE_SUFFIX_STRING
+    val AVOID_CLASH_SUFFIX: N         = "$_avoid_name_clash_$"
     val MODULE_VAR_SUFFIX: N          = "$module"
     val NAME_JOIN: N                  = NameTransformer.NAME_JOIN_STRING
     val USCORE_PARAM_PREFIX: N        = "_$"

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -171,9 +171,14 @@ object SymDenotations {
       myInfo = tp
     }
 
-    /** The name, except if this is a module class, strip the module class suffix */
+    /** The name, except 
+     *   - if this is a module class, strip the module class suffix 
+     *   - if this is a companion object with a clash-avoiding name, strip the 
+     *     "avoid clash" suffix
+     */
     def effectiveName(implicit ctx: Context) =
-      if (this is ModuleClass) name.stripModuleClassSuffix else name
+      if (this is ModuleClass) name.stripModuleClassSuffix 
+      else name.stripAvoidClashSuffix
 
     /** The privateWithin boundary, NoSymbol if no boundary is given.
      */

src/dotty/tools/dotc/core/Types.scala

@@ -2976,7 +2976,7 @@ object Types {
       val ex = new CyclicReference(denot)
       if (!(ctx.mode is typer.Mode.CheckCyclic)) {
         cyclicErrors.println(ex.getMessage)
-        for (elem <- ex.getStackTrace take 40)
+        for (elem <- ex.getStackTrace take 50)
           cyclicErrors.println(elem.toString)
       }
       ex

src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -81,7 +81,15 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
 
     def addMissingCompanions(stats: List[Tree]): List[Tree] = stats map {
       case stat: TypeDef if singleClassDefs contains stat.name =>
-        Thicket(stat :: newCompanion(stat.name.toTermName).trees)
+        val objName = stat.name.toTermName
+        val nameClash = stats.exists {
+          case other: MemberDef => 
+            other.name == objName && other.symbol.info.isParameterless
+          case _ =>
+            false
+        }
+        val uniqueName = if (nameClash) objName.avoidClashName else objName
+        Thicket(stat :: newCompanion(uniqueName).trees)
       case stat => stat
     }
 

src/dotty/tools/dotc/typer/Namer.scala

@@ -674,7 +674,15 @@ class Namer { typer: Typer =>
 
   def typeDefSig(tdef: TypeDef, sym: Symbol)(implicit ctx: Context): Type = {
     completeParams(tdef.tparams)
-    sym.info = TypeBounds.empty
+    val tparamSyms = tdef.tparams map symbolOfTree
+    val isDerived = tdef.rhs.isInstanceOf[untpd.DerivedTypeTree]
+    val toParameterize = tparamSyms.nonEmpty && !isDerived
+    val needsLambda = sym.allOverriddenSymbols.exists(_ is HigherKinded) && !isDerived
+    def abstracted(tp: Type): Type = 
+      if (needsLambda) tp.LambdaAbstract(tparamSyms)
+      else if (toParameterize) tp.parameterizeWith(tparamSyms)
+      else tp
+    sym.info = abstracted(TypeBounds.empty)
       // Temporarily set info of defined type T to ` >: Nothing <: Any.
       // This is done to avoid cyclic reference errors for F-bounds.
       // This is subtle: `sym` has now an empty TypeBounds, but is not automatically
@@ -685,18 +693,10 @@ class Namer { typer: Typer =>
       //
       // The scheme critically relies on an implementation detail of isRef, which
       // inspects a TypeRef's info, instead of simply dealiasing alias types.
-    val tparamSyms = tdef.tparams map symbolOfTree
-    val isDerived = tdef.rhs.isInstanceOf[untpd.DerivedTypeTree]
-    val toParameterize = tparamSyms.nonEmpty && !isDerived
-    val needsLambda = sym.allOverriddenSymbols.exists(_ is HigherKinded) && !isDerived
     val rhsType = typedAheadType(tdef.rhs).tpe
-    def abstractedRhsType =
-      if (needsLambda) rhsType.LambdaAbstract(tparamSyms)
-      else if (toParameterize) rhsType.parameterizeWith(tparamSyms)
-      else rhsType
     val unsafeInfo = rhsType match {
-      case _: TypeBounds => abstractedRhsType.asInstanceOf[TypeBounds]
-      case _ => TypeAlias(abstractedRhsType, if (sym is Local) sym.variance else 0)
+      case _: TypeBounds => abstracted(rhsType).asInstanceOf[TypeBounds]
+      case _ => TypeAlias(abstracted(rhsType), if (sym is Local) sym.variance else 0)
     }
     sym.info = NoCompleter
     checkNonCyclic(sym, unsafeInfo, reportErrors = true)

src/dotty/tools/dotc/typer/RefChecks.scala

@@ -184,12 +184,6 @@ object RefChecks {
           emitOverrideError(overrideErrorMsg(msg))
       }
 
-      def overrideTypeError() = {
-        if (noErrorType) {
-          emitOverrideError(overrideErrorMsg("has incompatible type"))
-        }
-      }
-
       def overrideAccessError() = {
         ctx.log(i"member: ${member.showLocated} ${member.flags}") // DEBUG
         ctx.log(i"other: ${other.showLocated} ${other.flags}") // DEBUG