Enforce no shadowing restriction

Author: odersky

compiler/src/dotty/tools/dotc/ast/MainProxies.scala

@@ -40,7 +40,7 @@ object MainProxies {
   }
 
   private def checkNoShadowing(mainFun: Symbol)(using Context) =
-    val cls = ctx.typer.findRef(mainFun.name.toTypeName, WildcardType, EmptyFlags, mainFun).typeSymbol
+    val cls = ctx.typer.findRef(mainFun.name.toTypeName, WildcardType, EmptyFlags, EmptyFlags, mainFun).typeSymbol
     if cls.exists && cls.owner != ctx.owner then
       report.warning(
         i"""The class `${ctx.printer.fullNameString(mainFun)}` generated from `@main` will shadow the existing ${cls.showLocated}.

compiler/src/dotty/tools/dotc/core/ContextOps.scala

@@ -25,21 +25,22 @@ object ContextOps:
 
     /** The denotation with the given `name` and all `required` flags in current context
      */
-    def denotNamed(name: Name, required: FlagSet = EmptyFlags): Denotation = inContext(ctx) {
-      if (ctx.owner.isClass)
-        if (ctx.outer.owner == ctx.owner) { // inner class scope; check whether we are referring to self
-          if (ctx.scope.size == 1) {
-            val elem = ctx.scope.lastEntry
-            if (elem.name == name) return elem.sym.denot // return self
+    def denotNamed(name: Name, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation =
+      inContext(ctx) {
+        if (ctx.owner.isClass)
+          if (ctx.outer.owner == ctx.owner) { // inner class scope; check whether we are referring to self
+            if (ctx.scope.size == 1) {
+              val elem = ctx.scope.lastEntry
+              if (elem.name == name) return elem.sym.denot // return self
+            }
+            val pre = ctx.owner.thisType
+            pre.findMember(name, pre, required, excluded)
           }
-          val pre = ctx.owner.thisType
-          pre.findMember(name, pre, required, EmptyFlags)
-        }
-        else // we are in the outermost context belonging to a class; self is invisible here. See inClassContext.
-          ctx.owner.findMember(name, ctx.owner.thisType, required, EmptyFlags)
-      else
-        ctx.scope.denotsNamed(name).filterWithFlags(required, EmptyFlags).toDenot(NoPrefix)
-    }
+          else // we are in the outermost context belonging to a class; self is invisible here. See inClassContext.
+            ctx.owner.findMember(name, ctx.owner.thisType, required, excluded)
+        else
+          ctx.scope.denotsNamed(name).filterWithFlags(required, excluded).toDenot(NoPrefix)
+      }
 
     /** A fresh local context with given tree and owner.
     *  Owner might not exist (can happen for self valdefs), in which case

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -135,12 +135,16 @@ class Typer extends Namer
    *   @param name       the name of the identifier
    *   @param pt         the expected type
    *   @param required   flags the result's symbol must have
+   *   @param excluded   flags the result's symbol must not have
    *   @param pos        indicates position to use for error reporting
    */
-  def findRef(name: Name, pt: Type, required: FlagSet, pos: SrcPos)(using Context): Type = {
+  def findRef(name: Name, pt: Type, required: FlagSet, excluded: FlagSet, pos: SrcPos)(using Context): Type = {
     val refctx = ctx
     val noImports = ctx.mode.is(Mode.InPackageClauseName)
-    def fail(msg: Message) = report.error(msg, pos)
+    def suppressErrors = excluded.is(ConstructorProxy)
+      // when searching for references shadowed by a constructor proxy, do not report errors
+    def fail(msg: Message) =
+      if !suppressErrors then report.error(msg, pos)
 
     /** A symbol qualifies if it really exists and is not a package class.
      *  In addition, if we are in a constructor of a pattern, we ignore all definitions
@@ -204,7 +208,7 @@ class Typer extends Namer
         imp.sym.info match
           case ImportType(expr) =>
             val pre = expr.tpe
-            var denot = pre.memberBasedOnFlags(name, required, EmptyFlags)
+            var denot = pre.memberBasedOnFlags(name, required, excluded)
               .accessibleFrom(pre)(using refctx)
             // Pass refctx so that any errors are reported in the context of the
             // reference instead of the context of the import scope
@@ -332,7 +336,7 @@ class Typer extends Namer
               val scope = if owner.isClass then owner.info.decls else outer.scope
               if scope.lookup(name).exists then
                 val symsMatch = scope.lookupAll(name).exists(denot.containsSym)
-                if !symsMatch then
+                if !symsMatch && !suppressErrors then
                   report.errorOrMigrationWarning(
                     AmbiguousReference(name, Definition, Inheritance, prevCtx)(using outer),
                     pos)
@@ -344,7 +348,7 @@ class Typer extends Namer
                 checkNoOuterDefs(denot, outer, prevCtx)
 
           if isNewDefScope then
-            val defDenot = ctx.denotNamed(name, required)
+            val defDenot = ctx.denotNamed(name, required, excluded)
             if (qualifies(defDenot)) {
               val found =
                 if (isSelfDenot(defDenot)) curOwner.enclosingClass.thisType
@@ -462,7 +466,7 @@ class Typer extends Namer
       unimported = Set.empty
       foundUnderScala2 = NoType
       try
-        val found = findRef(name, pt, EmptyFlags, tree.srcPos)
+        val found = findRef(name, pt, EmptyFlags, EmptyFlags, tree.srcPos)
         if foundUnderScala2.exists && !(foundUnderScala2 =:= found) then
           report.migrationWarning(
             ex"""Name resolution will change.
@@ -474,7 +478,17 @@ class Typer extends Namer
       	unimported = saved1
       	foundUnderScala2 = saved2
 
+    def checkNotShadowed(ownType: Type) = ownType match
+      case ownType: TermRef if ownType.symbol.is(ConstructorProxy) =>
+        val shadowed = findRef(name, pt, EmptyFlags, ConstructorProxy, tree.srcPos)
+        if shadowed.exists then
+          report.error(
+            em"""Reference to creator proxy for ${ownType.symbol.companionClass.showLocated}
+                |shadows outer reference to ${shadowed.termSymbol.showLocated}""", tree.srcPos)
+      case _ =>
+
     def setType(ownType: Type): Tree =
+      checkNotShadowed(ownType)
       val tree1 = ownType match
         case ownType: NamedType if !prefixIsElidable(ownType) =>
           ref(ownType).withSpan(tree.span)
@@ -3484,10 +3498,10 @@ class Typer extends Namer
         case selProto @ SelectionProto(selName: TermName, mbrType, _, _) =>
           def tryExtension(using Context): Tree =
             try
-              findRef(selName, WildcardType, ExtensionMethod, tree.srcPos) match
+              findRef(selName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
                 case ref: TermRef =>
                   extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
-                case _ => findRef(selProto.extensionName, WildcardType, ExtensionMethod, tree.srcPos) match
+                case _ => findRef(selProto.extensionName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
                   case ref: TermRef =>
                     extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
                   case _ => EmptyTree

tests/neg/constructor-proxy-shadowing.scala

@@ -0,0 +1,10 @@
+
+object Test extends App {
+  def A22(s: String): String = s
+  class A {
+    class A22(s: String) {
+      def run = s
+    }
+    val x = A22("") // error: shadowing
+  }
+}

tests/pos/t522.scala

@@ -1,9 +1,9 @@
 package imptwice
 
-class foo(s: String);
+abstract class foo(s: String);
 
 object Util {
-  def foo(s: String) = new foo(s)
+  def foo(s: String) = new foo(s) {}
 }
 
 import imptwice.Util._