Experimental typeImports

compiler/importer.nim

@@ -68,6 +68,22 @@ proc rawImportSymbol(c: PContext, s: PSym) =
     if s.kind == skConverter: addConverter(c, s)
     if hasPattern(s): addPattern(c, s)
 
+proc maybeImportForType(c: PContext, s: PSym, t: PType) =
+  ## Imports a symbol only if it has a strict relation with a type:
+  ##
+  ##  - Proc refers to the type on any of its input or output values.
+  ##
+  ## TODO: generics are not matched currently.
+  ##
+  case s.kind
+  of skProcKinds:
+    for tt in s.typ.sons.items:
+      if t == tt:
+        rawImportSymbol(c, s)
+        break
+  else:
+    discard
+
 proc importSymbol(c: PContext, n: PNode, fromMod: PSym) =
   let ident = lookups.considerQuotedIdent(c, n)
   let s = strTableGet(fromMod.tab, ident)
@@ -88,6 +104,19 @@ proc importSymbol(c: PContext, n: PNode, fromMod: PSym) =
         if e.name.id != s.name.id: internalError(c.config, n.info, "importSymbol: 3")
         rawImportSymbol(c, e)
         e = nextIdentIter(it, fromMod.tab)
+
+    of skType:
+      # import the type as expected
+      rawImportSymbol(c, s)
+
+      # types can bring attached their related symbols too
+      if typeImports in c.features:
+        var i: TTabIter
+        var ss = initTabIter(i, fromMod.tab)
+        while ss != nil:
+          maybeImportForType(c, ss, s.typ)
+          ss = nextIter(i, fromMod.tab)
+
     else: rawImportSymbol(c, s)
 
 proc importAllSymbolsExcept(c: PContext, fromMod: PSym, exceptSet: IntSet) =

compiler/options.nim

@@ -120,7 +120,8 @@ type
     notnil,
     dynamicBindSym,
     forLoopMacros,
-    caseStmtMacros
+    caseStmtMacros,
+    typeImports
 
   SymbolFilesOption* = enum
     disabledSf, writeOnlySf, readOnlySf, v2Sf

doc/manual.rst

@@ -6333,6 +6333,24 @@ It's also possible to use ``from module import nil`` if one wants to import
 the module but wants to enforce fully qualified access to every symbol
 in ``module``.
 
+By using the experimental feature ``typeImports`` it's possible to bring
+all the symbols directly related to a type. Any callable that has the imported
+type as one of its arguments or return type gets automatically included with the
+import.
+
+.. code-block:: nim
+    :test: "nim c $1"
+
+  {.experimental: "typeImports".}
+
+  from colors import Color
+
+  # to string and proc imported
+  let pink = rgb(255, 192, 203)
+  echo $pink
+  # color constants are not imported though, this would fail:
+  # echo $colBlue
+
 
 Export statement
 ~~~~~~~~~~~~~~~~

tests/modules/ttypeimport.nim

@@ -0,0 +1,11 @@
+discard """
+  output: "#FFC0CB"
+"""
+
+{.experimental: "typeImports".}
+
+from colors import Color
+
+# to string and proc imported
+let pink = rgb(255, 192, 203)
+echo $pink

tests/modules/ttypeimportfail.nim

@@ -0,0 +1,11 @@
+discard """
+  file: "ttypeimportfail.nim"
+  errormsg: "undeclared identifier: 'colBlue'"
+"""
+
+{.experimental: "typeImports".}
+
+from colors import Color
+
+# constants of the type not imported
+discard colBlue