chore: add support for *unqualified selectors*

Author: hamzaremmal

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2368,6 +2368,7 @@ object Parsers {
      *                      |  `try' Expr [`finally' Expr]
      *                      |  `throw' Expr
      *                      |  `return' [Expr]
+     *                      |  `.` id
      *                      |  ForExpr
      *                      |  [SimpleExpr `.'] id `=' Expr
      *                      |  PrefixOperator SimpleExpr `=' Expr
@@ -2756,6 +2757,7 @@ object Parsers {
      *  SimpleExpr1   ::= literal
      *                 |  xmlLiteral
      *                 |  SimpleRef
+     *                 |  `.` id
      *                 |  `(` [ExprsInParens] `)`
      *                 |  SimpleExpr `.` id
      *                 |  SimpleExpr `.` MatchClause
@@ -2800,6 +2802,9 @@ object Parsers {
         case MACRO =>
           val start = in.skipToken()
           MacroTree(simpleExpr(Location.ElseWhere))
+        case DOT =>
+          accept(DOT)
+          selector(EmptyTree)
         case _ =>
           if isLiteral then
             literal()

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -227,7 +227,7 @@ object Tokens extends TokensCommon {
     | BitSet(QUOTE, NEW)
 
   final val canStartExprTokens3: TokenSet =
-    canStartInfixExprTokens | BitSet(INDENT, IF, WHILE, FOR, TRY, THROW)
+    canStartInfixExprTokens | BitSet(INDENT, IF, WHILE, FOR, TRY, THROW, DOT)
 
   final val canStartExprTokens2: TokenSet = canStartExprTokens3 | BitSet(DO)
 

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

@@ -1096,10 +1096,15 @@ trait Applications extends Compatibility {
           if tpt.isType && typedAheadType(tpt).tpe.typeSymbol.typeParams.isEmpty then
             IgnoredProto(pt)
           else
-            pt // Don't ignore expected value types of `new` expressions with parameterized type.
-                // If we have a `new C()` with expected type `C[T]` we want to use the type to
-                // instantiate `C` immediately. This is necessary since `C` might _also_ have using
-                // clauses that we want to instantiate with the best available type. See i15664.scala.
+            // Don't ignore expected value types of `new` expressions with parameterized type.
+            // If we have a `new C()` with expected type `C[T]` we want to use the type to
+            // instantiate `C` immediately. This is necessary since `C` might _also_ have using
+            // clauses that we want to instantiate with the best available type. See i15664.scala.
+            pt
+        // When typing the selector of an `Apply` node, and if the selector is `unqualifed` (e.g. `.some(10)`)
+        // We preserve the prototype `pt` and keep it in the prototype passed to type the selector.
+        // Unqualified selectors relies on the expected type to resolve the qualifier of the selection.
+        case Select(EmptyTree, name) => pt
         case _ => IgnoredProto(pt)
           // Do ignore other expected result types, since there might be an implicit conversion
           // on the result. We could drop this if we disallow unrestricted implicit conversions.

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

@@ -1037,7 +1037,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
     record("typedSelect")
 
-    def typeSelectOnTerm(using Context): Tree =
+    def typeSelectOnTerm(tree: untpd.Select)(using Context): Tree =
       if ctx.isJava then
         // permitted selection depends on Java context (type or expression).
         // we don't propagate (as a mode) whether a.b.m is a type name; OK since we only see type contexts.
@@ -1111,9 +1111,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     else if (ctx.isJava && tree.name.isTypeName)
       // scala/bug#3120 Java uses the same syntax, A.B, to express selection from the
       // value A and from the type A. We have to try both. (possibly exponential bc of qualifier retyping)
-      tryAlternatively(typeSelectOnTerm)(tryJavaSelectOnType)
+      tryAlternatively(typeSelectOnTerm(tree))(tryJavaSelectOnType)
+    else if tree.qualifier.isEmpty then
+      // TODO: Specify and develop the logic to resolve the qualifier here
+      val companion = pt.resultType.typeSymbol.companionModule
+      val qualified = cpy.Select(tree)(qualifier = untpd.ref(companion), name = tree.name)
+      typeSelectOnTerm(qualified)
     else
-      typeSelectOnTerm
+      typeSelectOnTerm(tree)
 
     warnUnnecessaryNN(tree1)
     tree1

tests/pos/unqualified-selector-enum.scala

@@ -0,0 +1,12 @@
+enum Opt[+T]:
+  case none extends Opt[Nothing]
+  case some[T](value: T) extends Opt[T]
+
+object Proxy:
+  def opt(o: Opt[Int]): Opt[Int] = o
+
+val _: Opt[Int] = .some(10)
+val _: Opt[Any] = .none
+
+val _ = Proxy.opt(.some(10))
+val _ = Proxy.opt(.none)

tests/pos/unqualified-selector-object.scala

@@ -0,0 +1,8 @@
+class Opt[+T](v: T)
+
+object Opt:
+  def some[T](b: T): Opt[T] = Opt(b)
+  val none: Opt[Nothing] = ???
+
+val _: Opt[Int] = .some(10)
+val _: Opt[Int] = .none