Export: syntax and parsing

Author: odersky

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

@@ -1403,7 +1403,7 @@ object Trees {
               this(x, rhs)
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
               this(this(this(this(x, constr), parents), self), tree.body)
-            case Import(importImplied, expr, selectors) =>
+            case Import(_, expr, _) =>
               this(x, expr)
             case PackageDef(pid, stats) =>
               this(this(x, pid), stats)(localCtx)

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

@@ -103,6 +103,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class GenAlias(pat: Tree, expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
   case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
   case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
+  case class Export(impliedOnly: Boolean, expr: Tree, selectors: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree
+
+  /** Short-lived usage in typer, does not need copy/transform/fold infrastructure */
   case class DependentTypeTree(tp: List[Symbol] => Type)(implicit @constructorOnly src: SourceFile) extends Tree
 
   @sharable object EmptyTypeIdent extends Ident(tpnme.EMPTY)(NoSource) with WithoutTypeOrPos[Untyped] {
@@ -532,6 +535,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
       case _ => finalize(tree, untpd.PatDef(mods, pats, tpt, rhs)(tree.source))
     }
+    def Export(tree: Tree)(impliedOnly: Boolean, expr: Tree, selectors: List[Tree])(implicit ctx: Context): Tree = tree match {
+      case tree: Export if (impliedOnly == tree.impliedOnly) && (expr eq tree.expr) && (selectors eq tree.selectors) => tree
+      case _ => finalize(tree, untpd.Export(impliedOnly, expr, selectors)(tree.source))
+    }
     def TypedSplice(tree: Tree)(splice: tpd.Tree)(implicit ctx: Context): ProxyTree = tree match {
       case tree: TypedSplice if splice `eq` tree.splice => tree
       case _ => finalize(tree, untpd.TypedSplice(splice)(ctx))
@@ -584,6 +591,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
       case PatDef(mods, pats, tpt, rhs) =>
         cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
+      case Export(impliedOnly, expr, selectors) =>
+        cpy.Export(tree)(impliedOnly, transform(expr), selectors)
       case TypedSplice(_) =>
         tree
       case _ =>
@@ -637,6 +646,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(this(x, bounds), cxBounds)
       case PatDef(mods, pats, tpt, rhs) =>
         this(this(this(x, pats), tpt), rhs)
+      case Export(_, expr, _) =>
+        this(x, expr)
       case TypedSplice(splice) =>
         this(x, splice)
       case _ =>

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

@@ -2225,13 +2225,16 @@ object Parsers {
     def finalizeDef(md: MemberDef, mods: Modifiers, start: Int): md.ThisTree[Untyped] =
       md.withMods(mods).setComment(in.getDocComment(start))
 
+    type ImportConstr = (Boolean, Tree, List[Tree]) => Tree
+
     /** Import  ::= import [implied] [ImportExpr {`,' ImportExpr}
+     *  Export  ::= export [implied] [ImportExpr {`,' ImportExpr}
      */
-    def importClause(): List[Tree] = {
-      val offset = accept(IMPORT)
+    def importClause(leading: Token, mkTree: ImportConstr): List[Tree] = {
+      val offset = accept(leading)
       val importImplied = in.token == IMPLIED
       if (importImplied) in.nextToken()
-      commaSeparated(importExpr(importImplied)) match {
+      commaSeparated(importExpr(importImplied, mkTree)) match {
         case t :: rest =>
           // The first import should start at the start offset of the keyword.
           val firstPos =
@@ -2244,23 +2247,28 @@ object Parsers {
 
     /**  ImportExpr ::= StableId `.' (id | `_' | ImportSelectors)
      */
-    def importExpr(importImplied: Boolean): () => Import = {
+    def importExpr(importImplied: Boolean, mkTree: ImportConstr): () => Tree = {
 
       val handleImport: Tree => Tree = { tree: Tree =>
-        if (in.token == USCORE) Import(importImplied, tree, importSelector() :: Nil)
-        else if (in.token == LBRACE) Import(importImplied, tree, inBraces(importSelectors()))
+        if (in.token == USCORE) mkTree(importImplied, tree, importSelector() :: Nil)
+        else if (in.token == LBRACE) mkTree(importImplied, tree, inBraces(importSelectors()))
         else tree
       }
 
-      () => path(thisOK = false, handleImport) match {
-        case imp: Import =>
-          imp
-        case sel @ Select(qual, name) =>
-          val selector = atSpan(pointOffset(sel)) { Ident(name) }
-          cpy.Import(sel)(importImplied, qual, selector :: Nil)
-        case t =>
-          accept(DOT)
-          Import(importImplied, t, Ident(nme.WILDCARD) :: Nil)
+      def derived(impExp: Tree, qual: Tree, selectors: List[Tree]) =
+        mkTree(impliedOnly, qual, selectors).withSpan(impExp.span)
+
+      () => {
+        val p = path(thisOK = false, handleImport)
+        p match {
+          case _: Import | _: Export => p
+          case sel @ Select(qual, name) =>
+            val selector = atSpan(pointOffset(sel)) { Ident(name) }
+            mkTree(importImplied, qual, selector :: Nil).withSpan(sel.span)
+          case t =>
+            accept(DOT)
+            mkTree(importImplied, t, Ident(nme.WILDCARD) :: Nil)
+        }
       }
     }
 
@@ -2769,7 +2777,7 @@ object Parsers {
           else stats += packaging(start)
         }
         else if (in.token == IMPORT)
-          stats ++= importClause()
+          stats ++= importClause(IMPORT, Import)
         else if (in.token == AT || isDefIntro(modifierTokens))
           stats +++= defOrDcl(in.offset, defAnnotsMods(modifierTokens))
         else if (!isStatSep) {
@@ -2816,7 +2824,9 @@ object Parsers {
       while (!isStatSeqEnd && !exitOnError) {
         setLastStatOffset()
         if (in.token == IMPORT)
-          stats ++= importClause()
+          stats ++= importClause(IMPORT, Import)
+        else if (in.token == EXPORT)
+          stats ++= importClause(EXPORT, Export.apply)
         else if (isExprIntro)
           stats += expr1()
         else if (isDefIntro(modifierTokensOrCase))
@@ -2888,7 +2898,7 @@ object Parsers {
       while (!isStatSeqEnd && in.token != CASE && !exitOnError) {
         setLastStatOffset()
         if (in.token == IMPORT)
-          stats ++= importClause()
+          stats ++= importClause(IMPORT, Import)
         else if (in.token == GIVEN)
           stats += implicitClosure(in.offset, Location.InBlock, modifiers(closureMods))
         else if (isExprIntro)

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

@@ -180,7 +180,8 @@ object Tokens extends TokensCommon {
   final val ERASED = 63;           enter(ERASED, "erased")
   final val IMPLIED = 64;          enter(IMPLIED, "implied")
   final val GIVEN = 65;            enter(GIVEN, "given")
-  final val MACRO = 66;            enter(MACRO, "macro") // TODO: remove
+  final val EXPORT = 66;           enter(EXPORT, "export")
+  final val MACRO = 67;            enter(MACRO, "macro") // TODO: remove
 
   /** special symbols */
   final val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
@@ -240,7 +241,7 @@ object Tokens extends TokensCommon {
   final val modifierFollowers = modifierTokens | defIntroTokens
 
   /** Is token only legal as start of statement (eof also included)? */
-  final val mustStartStatTokens: TokenSet = defIntroTokens | modifierTokens | BitSet(IMPORT, PACKAGE)
+  final val mustStartStatTokens: TokenSet = defIntroTokens | modifierTokens | BitSet(IMPORT, EXPORT, PACKAGE)
 
   final val canStartStatTokens: TokenSet = canStartExpressionTokens | mustStartStatTokens | BitSet(
     AT, CASE)

docs/docs/internals/syntax.md

@@ -334,6 +334,7 @@ Import            ::=  ‘import’ [‘implied’] ImportExpr {‘,’ ImportEx
 ImportExpr        ::=  StableId ‘.’ (id | ‘_’ | ImportSelectors)                Import(expr, sels)
 ImportSelectors   ::=  ‘{’ {ImportSelector ‘,’} (ImportSelector | ‘_’) ‘}’
 ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]                                  Ident(name), Pair(id, id)
+Export            ::=  ‘export’ [‘implied’] ImportExpr {‘,’ ImportExpr}
 ```
 
 ### Declarations and Definitions
@@ -370,7 +371,8 @@ DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
                     |  ‘enum’ EnumDef
-                    |  ‘witness’ WitnessDef
+                    |  ‘implied’ InstanceDef
+                    |  Export
 ClassDef          ::=  id ClassConstr [Template]                                ClassDef(mods, name, tparams, templ)
 ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses        with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat
 ConstrMods        ::=  {Annotation} [AccessModifier]