Changes between Version 2 and Version 3 of Commentary/Compiler/UnusedImports

Timestamp:

07/01/09 05:16:18 (4 years ago)

Author:

igloo

Comment:

--

Commentary/Compiler/UnusedImports

@@ -113 +113 @@
 seeing the RdrNames, not by knowing that the name 'x' is used.
 
-I think that all lookups go through a single function, 
-   `RnEnv.lookupGreRn_maybe`
-So in `RnEnv.lookupGreRn_maybe`, if `(gre_prov gre)` is `(Imported _)`
-hen put `rdr_name` in a new
-{{{
-tcg_used_imports :: TcRef (Set RdrName)
-}}}
-in `TcGblEnv`.  All the `tcg_used_imports` are in scope; if not,
-we report an error and do not add it to `tct_used_imports`.
+I think that all lookups go through either, `RnEnv.lookupGreRn_maybe` or `RnEnv.lookup_sub_bndr`.
+So in `RnEnv.lookupGreRn_maybe`, if `(gre_prov gre)` is `(Imported _)`,
+and in `RnEnv.lookup_sub_bndr`,
+put `rdr_name` in a new
+{{{
+tcg_used_rdrnames :: TcRef (Set RdrName)
+}}}
+in `TcGblEnv`.  All the `tcg_used_rdrnames` are in scope; if not,
+we report an error and do not add it to `tcg_used_rdrnames`.
 
 Other notes
@@ -137 +137 @@
   * We can compare `ImportSpecs` for equality by their `SrcSpans`
 
-
-Also perhpas:
-
   * In `TcRnDriver.tcRnImports`, save import_decls in a new
   `tcg_rn_rdr_imports :: Maybe [LImportDecl RdrName]`
   in `TcGblEnv`
 
-  * In `RnNames.reportUnusedNames`, call a function that actually does the
-  hard work. The ugly part is when we have an import of Foo(..). Then we
-  need to dig through the environments, similar to what
-  `RnNames.exports_from_avail` does, so that we can expand the (..).
-
-
+----
+
+The algorithm for deciding which imports have been used is based around this datatype:
+{{{
+data ImportInfo = ImportInfo SrcSpan
+                             SDoc
+                             [RdrName] -- The names the import provides
+                             Bool -- Has it been used yet?
+                             [ImportInfo] -- Child import infos
+}}}
+Here are how some example imports map to trees of `ImportInfo`, assuming `Foo` exports `a`, `b`, `D(c1, c2)`:
+{{{
+import Foo
+->
+ImportInfo "Foo" ["a", "b", "D", "c1", "c2", "Foo.a", "Foo.b", "Foo.D", "Foo.c1", "Foo.c2"]
+
+import qualified Foo as Bar
+->
+ImportInfo "Foo" ["Bar.a", "Bar.b", "Bar.D", "Bar.c1", "Bar.c2"]
+
+import qualified Foo (a, D)
+->
+ImportInfo "Foo" []
+    ImportInfo "Foo" ["Foo.a"]
+    ImportInfo "Foo" ["Foo.D"]
+
+import qualified Foo hiding (a, D(..))
+->
+ImportInfo "Foo" ["Foo.b"]
+
+import Foo (D(c1, c2))
+->
+ImportInfo "Foo" []
+    ImportInfo "Foo" ["D", "Foo.D"]
+        ImportInfo "Foo" ["c1", "Foo.c1"]
+        ImportInfo "Foo" ["c2", "Foo.c2"]
+
+import qualified Foo (D(..))
+->
+ImportInfo "Foo" []
+    ImportInfo "Foo" ["Foo.D", "Foo.c1", "Foo.c2"]
+}}}
+
+If a node in the tree is marked as used, then so are all nodes above it. For example, given the tree
+{{{
+ImportInfo "Foo" []
+    ImportInfo "Foo" ["D", "Foo.D"]
+        ImportInfo "Foo" ["c1", "Foo.c1"]
+        ImportInfo "Foo" ["c2", "Foo.c2"]
+}}}
+a use of `"D"` marks both the first and second lines as used.
+
+When we come to giving warnings, if a node is unused then we warn about it, and do not descend into the rest of that subtree, as the node we warn about subsumes its children. If the node is marked as used then we descend, looking to see if any of its children are unused.
+
+These trees are built by `RnNames.mkImportInfo`. In `RnNames.warnUnusedImportDecls` we make two lists of `ImportInfo`s; one list contains all the explicit imports, e.g.
+{{{
+import Foo (a, b)
+}}}
+and the other contains the implicit imports, e.g.
+{{{
+import Foo
+import Foo hiding (a, b)
+}}}
+
+Then `RnNames.markUsages` is called for each `RdrName` that was used in the program. The current implementation marks all explicit import as used unless there are no such imports, in which case it marks all implicit imports as used. A small tweak to `markUsages` would allow it to mark only the first import it finds as used.
+
+As well as the `RdrName`s used in the source, we also need to mark as used the names that are exported. We first call `RnNames.expandExports` to expand `D(..)` into `D(c1, c2)`, and then call `RnNames.markExportUsages`. Normally this just marks the `RdrName`s as used in the same way that uses in the module body are handled, but it is also possible for an entire module to be "used", if `module Foo` is in the export list. In this case `RnNames.markModuleUsed` does the hard work, marking every module imported with that name as used.