Fix #9562: Restrict implied prefix to same extension block

Author: odersky

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

@@ -19,48 +19,48 @@ object ContextOps:
     def enter(sym: Symbol): Symbol = inContext(ctx) {
       ctx.owner match
         case cls: ClassSymbol => cls.classDenot.enter(sym)
-        case _ => scope.openForMutations.enter(sym)
+        case _ => ctx.scope.openForMutations.enter(sym)
       sym
     }
 
     /** The denotation with the given `name` and all `required` flags in current context
      */
     def denotNamed(name: Name, required: FlagSet = EmptyFlags): Denotation = inContext(ctx) {
-      if (owner.isClass)
-        if (outer.owner == owner) { // inner class scope; check whether we are referring to self
-          if (scope.size == 1) {
-            val elem = scope.lastEntry
+      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 = owner.thisType
+          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.
-          owner.findMember(name, owner.thisType, required, EmptyFlags)
+          ctx.owner.findMember(name, ctx.owner.thisType, required, EmptyFlags)
       else
-        scope.denotsNamed(name).filterWithFlags(required, EmptyFlags).toDenot(NoPrefix)
+        ctx.scope.denotsNamed(name).filterWithFlags(required, EmptyFlags).toDenot(NoPrefix)
     }
 
     /** A fresh local context with given tree and owner.
     *  Owner might not exist (can happen for self valdefs), in which case
     *  no owner is set in result context
     */
     def localContext(tree: untpd.Tree, owner: Symbol): FreshContext = inContext(ctx) {
-      val freshCtx = fresh.setTree(tree)
-      if (owner.exists) freshCtx.setOwner(owner) else freshCtx
+      val freshCtx = ctx.fresh.setTree(tree)
+      if owner.exists then freshCtx.setOwner(owner) else freshCtx
     }
 
     /** Context where `sym` is defined, assuming we are in a nested context. */
     def defContext(sym: Symbol): Context = inContext(ctx) {
-      outersIterator
+      ctx.outersIterator
         .dropWhile(_.owner != sym)
         .dropWhile(_.owner == sym)
         .next()
     }
 
     /** A new context for the interior of a class */
     def inClassContext(selfInfo: TypeOrSymbol): Context = inContext(ctx) {
-      val localCtx: Context = fresh.setNewScope
+      val localCtx: Context = ctx.fresh.setNewScope
       selfInfo match {
         case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
         case _ =>
@@ -69,7 +69,7 @@ object ContextOps:
     }
 
     def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context = inContext(ctx) {
-      if (pkg.is(Package)) fresh.setOwner(pkg.moduleClass).setTree(tree)
+      if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
       else ctx
     }
 end ContextOps

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -409,7 +409,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
 
   /** Is this an anonymous class deriving from an enum definition? */
   extension (cls: ClassSymbol) private def isEnumValueImplementation(using Context): Boolean =
-    isAnonymousClass && classParents.head.typeSymbol.is(Enum) // asserted in Typer
+    cls.isAnonymousClass && cls.classParents.head.typeSymbol.is(Enum) // asserted in Typer
 
   /** If this is the class backing a serializable singleton enum value with base class `MyEnum`,
    *  and not deriving from `java.lang.Enum` add the method:

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

@@ -199,9 +199,10 @@ object Applications {
    *  I.e., if the expected type is a PolyProto, then `app` will be a `TypeApply(_, args)` where
    *  `args` are the type arguments of the expected type.
    */
-  class IntegratedTypeArgs(val app: Tree)(implicit @constructorOnly src: SourceFile) extends tpd.Tree {
+  class IntegratedTypeArgs(val app: Tree)(implicit @constructorOnly src: SourceFile) extends ProxyTree {
     override def span = app.span
 
+    def forwardTo = app
     def canEqual(that: Any): Boolean = app.canEqual(that)
     def productArity: Int = app.productArity
     def productElement(n: Int): Any = app.productElement(n)

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

@@ -1110,7 +1110,7 @@ trait Checking {
   def checkEnumParent(cls: Symbol, firstParent: Symbol)(using Context): Unit =
 
     extension (sym: Symbol) def typeRefApplied(using Context): Type =
-      typeRef.appliedTo(typeParams.map(_.info.loBound))
+      sym.typeRef.appliedTo(sym.typeParams.map(_.info.loBound))
 
     def ensureParentDerivesFrom(enumCase: Symbol)(using Context) =
       val enumCls = enumCase.owner.linkedClass

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

@@ -446,17 +446,7 @@ class Typer extends Namer
     // cyclic references.
     if (name == nme.ROOTPKG)
       return tree.withType(defn.RootPackage.termRef)
-
-    /** Convert a reference `f` to an extension method select `p.f`, where
-     *  `p` is the closest enclosing extension parameter, or else `this`.
-     */
-    def extensionMethodSelect: untpd.Tree =
-      val xmethod = ctx.owner.enclosingExtensionMethod
-      val qualifier =
-        if xmethod.exists then untpd.ref(xmethod.extensionParam.termRef)
-        else untpd.This(untpd.EmptyTypeIdent)
-      untpd.cpy.Select(tree)(qualifier, name)
-
+      
     val rawType = {
       val saved1 = unimported
       val saved2 = foundUnderScala2
@@ -507,7 +497,20 @@ class Typer extends Namer
     else if name.toTermName == nme.ERROR then
       setType(UnspecifiedErrorType)
     else if name.isTermName then
-      tryEither(typed(extensionMethodSelect, pt))((_, _) => fail)
+      // Convert a reference `f` to an extension method select `p.f`, where
+      // `p` is the closest enclosing extension parameter, or else convert to `this.f`.
+      val xmethod = ctx.owner.enclosingExtensionMethod
+      val qualifier =
+        if xmethod.exists then untpd.ref(xmethod.extensionParam.termRef)
+        else untpd.This(untpd.EmptyTypeIdent)
+      val selection = untpd.cpy.Select(tree)(qualifier, name)
+      val result = tryEither(typed(selection, pt))((_, _) => fail)
+      def canAccessUnqualified(sym: Symbol) =
+        sym.isExtensionMethod && (sym.extensionParam.span == xmethod.extensionParam.span)
+      if !xmethod.exists || result.tpe.isError || canAccessUnqualified(result.symbol) then
+        result
+      else
+        fail
     else
       fail
   end typedIdent

tests/neg/i9562.scala

@@ -0,0 +1,12 @@
+class Foo:
+  def foo = 23
+
+object Unrelated:
+  extension (f: Foo)
+    def g = f.foo // OK
+
+  extension (f: Foo)
+    def h1: Int = foo     // error
+    def h2: Int = h1 + 1  // OK
+    def h3: Int = g       // error
+    def ++: (x: Int): Int = h1 + x  // OK