starting to push through transitive re-exports of data

Author: jpolitz

src/arr/compiler/ast-util.arr

@@ -1161,7 +1161,10 @@ fun get-named-provides(resolved :: CS.NameResolution, uri :: URI, compile-env ::
           data-provides = for fold(dp from [SD.string-dict:], d from dp-specs):
             cases(A.NameSpec) d.name-spec:
               | s-remote-ref(l, shadow uri, name, as-name) =>
-                raise("Cannot alias data right now")
+                # dp.set(as-name.toname(), T.t-name(T.module-uri(uri), name, l, false))
+                # raise("Cannot alias data right now")
+
+                dp #NOTE(joe): the type alias does the work here, and datatypes are ONLY stored on the module in which they are defined
               | s-local-ref(l, name, as-name) =>
                 exp = resolved.env.datatypes.get-value-now(name.toname())
                 dp.set(exp.name, data-expr-to-datatype(exp))
@@ -1245,6 +1248,7 @@ fun find-mod(compile-env, uri) -> Option<String>:
   end
 end
 
+
 fun transform-dict-helper(canonicalizer):
   lam(d, uri, transformer):
     for SD.fold-keys(s from [SD.string-dict: ], v from d):
@@ -1279,21 +1283,7 @@ fun canonicalize-provides(provides :: CS.Provides, compile-env :: CS.CompileEnvi
     | t-name(origin, name, loc, inferred) =>
       cases(T.NameOrigin) origin:
       | local => T.t-name(T.module-uri(provides.from-uri), name, loc, inferred)
-      | module-uri(uri) =>
-        cases(Option<String>) find-mod(compile-env, uri):
-        | some(_) => T.t-name(T.module-uri(uri), name, loc, inferred)
-        | none =>
-          if string-index-of(uri, "builtin://") == 0:
-            T.t-name(T.module-uri(uri), name, loc, inferred)
-          else if uri == provides.from-uri:
-            T.t-name(T.module-uri(uri), name, loc, inferred)
-          else:
-          # TODO(joe): This should become an error once things are localized again
-
-            #T.t-name(T.module-uri(uri), name, loc)
-            raise("Unknown module URI for type: " + torepr(t) + " in provides for " + provides.from-uri)
-          end
-        end
+      | module-uri(uri) => t
       | dependency(d) =>
         provides-for-d = compile-env.provides-by-dep-key(d)
         cases(Option<CS.Provides>) provides-for-d:
@@ -1323,18 +1313,7 @@ fun localize-provides(provides :: CS.Provides, compile-env :: CS.CompileEnvironm
         if uri == provides.from-uri:
           T.t-name(T.local, name, loc, inferred)
         else:
-          cases(Option<String>) find-mod(compile-env, uri):
-          | some(d) => T.t-name(T.dependency(d), name, loc, inferred)
-          | none =>
-            if string-index-of(uri, "builtin://") == 0:
-              T.t-name(T.module-uri(uri), name, loc, inferred)
-            else:
-              # TODO(joe): This should become an error once things are localized again
-              #T.t-name(T.module-uri(uri), name, loc)
-
-              raise("Unknown module URI for type: " + torepr(t) + " in provides for " + provides.from-uri)
-            end
-          end
+          t
         end
       | dependency(d) =>
         provides-for-d = compile-env.my-modules.get(d)
@@ -1412,7 +1391,10 @@ fun get-typed-provides(resolved, typed :: TCS.Typed, uri :: URI, compile-env ::
           data-provides = for fold(dp from [SD.string-dict:], d from dp-specs):
             cases(A.NameSpec) d.name-spec:
               | s-remote-ref(l, shadow uri, name, as-name) =>
-                raise("Cannot alias data right now")
+                # dp.set(as-name.toname(), T.t-name(T.module-uri(uri), name, l, false))
+                # raise("Cannot alias data right now")
+
+                dp #NOTE(joe): the type alias does the work here, and datatypes are ONLY stored on the module in which they are defined
               | s-local-ref(l, name, _) =>
                 exp = resolved.env.datatypes.get-value-now(name.toname())
                 dp.set(exp.name, canonicalize-data-type(typed.info.data-types.get-value(exp.namet.key()), uri, transformer))

src/arr/compiler/resolve-scope.arr

@@ -1088,11 +1088,30 @@ fun resolve-names(p :: A.Program, initial-env :: C.CompileEnvironment):
       # names and atoms that will be exposed. The atoms will be used by code
       # generation and by the type-checker/cross-module scope resolution to
       # pick out information about the binding (e.g. flatness, etc)
+      # The actual values in the dictionaries are triples of
+      #
+      #  {Srcloc; Option<URI>; Atom}
+      #
+      # The location is the location of the provide clause, the URI is none if
+      # the name is provided from this module, and some if it is re-provided
+      # from another module
       provided-modules = [SD.mutable-string-dict:]
       provided-values = [SD.mutable-string-dict:]
       provided-types = [SD.mutable-string-dict:]
       provided-datatypes = [SD.mutable-string-dict:]
 
+      fun is-hidden(hidden :: List<A.Name>, maybe-hidden-name :: String):
+        for lists.any(h from hidden):
+          h.name == maybe-hidden-name
+        end
+      end
+
+      fun maybe-add(hidden, which-dict, maybe-add-name :: String, to-add):
+        when not(is-hidden(hidden, maybe-add-name)):
+          which-dict.set-now(maybe-add-name, to-add)
+        end
+      end
+
       fun expand-name-spec(which-dict, which-bindings, which-env, spec, pre-path):
         cases(A.NameSpec) spec:
           | s-star(shadow l, hidden) =>
@@ -1122,27 +1141,75 @@ fun resolve-names(p :: A.Program, initial-env :: C.CompileEnvironment):
             end
         end
       end
-      fun expand-data-spec(spec, pre-path):
+      fun expand-data-spec(val-env, type-env, spec, pre-path, hidden):
         cases(A.NameSpec) spec:
-          | s-star(shadow l, hidden) =>
+          | s-star(shadow l, _) => # NOTE(joe): Assumption is that this s-star's hiding is always empty for s-provide-data
             for each(k from datatypes.keys-list-now()):
               data-expr = datatypes.get-value-now(k)
+
+              # NOTE(joe): Trying this as a nice collapsing of cases
+              expand-data-spec(val-env, type-env, A.s-module-ref(l, [list: data-expr.name], none), hidden)
+
               # TODO(joe): need to check datatypes from elsewhere with .new-definition?
-              provided-datatypes.set-now(data-expr.name, {l; maybe-uri-for-path(pre-path, initial-env, final-visitor.module-env); data-expr.namet})
+              # provided-datatypes.set-now(data-expr.name, {l; maybe-uri-for-path(pre-path, initial-env, final-visitor.module-env); data-expr.namet})
             end
           | s-module-ref(shadow l, path, as-name) =>
             maybe-uri = path-uri(pre-path, path, initial-env, final-visitor.module-env)
-            {name; atom} = cases(Option) maybe-uri:
-              | none =>
+            cases(Option) maybe-uri block:
+              | none => # path must be a single element if there's no URI of a remote module
+                        # e.g. provide: D end   NOT    provide: M.D end
                 data-expr = datatypes.get-value-now(path.first.toname())
-                { data-expr.name; data-expr.namet }
-              | some(v) =>
-                { path.last().toname(); A.s-name(l, path.last().toname()) }
-            end
-            data-expr = datatypes.get-value-now(path.first.toname())
-            cases(Option) as-name:
-              | none => provided-datatypes.set-now(data-expr.name, {l; none; data-expr.namet})
-              | some(n) => raise("Cannot rename data using as")
+                maybe-add(hidden, provided-datatypes, data-expr.name, {l; none; data-expr.namet})
+                data-checker-name = A.make-checker-name(data-expr.name)
+                data-checker-vb = val-env.get-value(data-checker-name)
+                maybe-add(hidden, provided-values, data-checker-name, {l; none; data-checker-vb.atom})
+                data-alias-tb = type-env.get-value(data-expr.name)
+                maybe-add(hidden, provided-types, data-expr.name, {l; none; data-alias-tb.atom})
+                for each(v from data-expr.variants) block:
+                  variant-vb = val-env.get-value(v.name)
+                  checker-name = A.make-checker-name(v.name)
+                  variant-checker-vb = val-env.get-value(checker-name)
+                  maybe-add(hidden, provided-values, v.name, {l; none; variant-vb.atom})
+                  maybe-add(hidden, provided-values, checker-name, {l; none; variant-checker-vb.atom})
+                end
+                
+              | some(uri) =>
+                datatype-name = path.last().toname()
+                providing-module = initial-env.provides-by-uri-value(uri)
+                maybe-datatype = providing-module.data-definitions.get(datatype-name)
+                { datatype-uri; datatype } = cases(Option) maybe-datatype:
+                  | none => 
+                    cases(Option) providing-module.aliases.get(datatype-name):
+                      | none => raise("Name " + datatype-name + " not defined as a type or datatype on " + uri)
+                      | some(t) =>
+                        cases(T.Type) t block:
+                          | t-name(module-name, id, _, _) =>
+                            when(not(T.is-module-uri(module-name))): raise("Expected a remote reference: " + to-repr(module-name)) end
+
+                            remote-datatype = initial-env.provides-by-uri-value(module-name.uri).data-definitions.get(datatype-name)
+                            cases(Option) remote-datatype:
+                              | some(rd) => { module-name.uri; rd }
+                              | none =>
+                                raise("Cannot re-provide datatype " + datatype-name + " because it isn't a datatype in " + uri)
+                            end
+                        end
+                    end
+                  | some(datatype) => { uri; datatype }
+                end
+                fun add-value-if-defined(name):
+                  when(providing-module.values.has-key(name)):
+                    maybe-add(hidden, provided-values, name, {l; some(datatype-uri); A.s-name(l, name)})
+                  end
+                end
+                # maybe-add(hidden, provided-datatypes, datatype-name, {l; some(uri); A.s-name(l, datatype-name)})
+                add-value-if-defined(A.make-checker-name(datatype-name))
+                when(providing-module.aliases.has-key(datatype-name)):
+                  maybe-add(hidden, provided-types, datatype-name, {l; some(datatype-uri); A.s-name(l, datatype-name)})
+                end
+                for each(v from datatype.variants) block:
+                  add-value-if-defined(v.name)
+                  add-value-if-defined(A.make-checker-name(v.name))
+                end
             end
         end
       end
@@ -1155,7 +1222,7 @@ fun resolve-names(p :: A.Program, initial-env :: C.CompileEnvironment):
           | s-provide-module(shadow l, name-spec) =>
             expand-name-spec(provided-modules, module-bindings, final-visitor.module-env, name-spec, path)
           | s-provide-data(shadow l, name-spec, hidden) =>
-            expand-data-spec(name-spec, path)
+            expand-data-spec(final-visitor.env, final-visitor.type-env, name-spec, path, hidden)
           | else => nothing
         end
       end

src/arr/compiler/type-check-structs.arr

@@ -1354,6 +1354,7 @@ fun resolve-alias(t :: Type, context :: Context) -> Type:
       cases(TS.NameOrigin) a-mod:
         | dependency(d) => TS.dep-error(a-mod)
         | local =>
+          spy: aliases: context.aliases, key: a-id.key() end
           cases(Option) context.aliases.get(a-id.key()):
             | none => t
             | some(aliased) => resolve-alias(aliased, context).set-loc(l).set-inferred(inferred)

src/arr/compiler/type-check.arr

@@ -135,7 +135,7 @@ fun add-existentials-to-data-name(typ :: Type, context :: Context) -> FoldResult
     | t-name(_, _, _, inferred) =>
       cases(Option<DataType>) context.get-data-type(typ):
         | none =>
-          fold-errors([list: C.cant-typecheck("Expected a data type but got " + tostring(typ), typ.l)])
+          fold-errors([list: C.cant-typecheck("Expected a data type but got " + to-repr(typ), typ.l)])
         | some(data-type) =>
           if is-empty(data-type.params):
             fold-result(typ, context)

src/arr/compiler/type-structs.arr

@@ -575,9 +575,11 @@ sharing:
     end, 1, SD.make-string-dict(), free-vars-list)
     helper(self, free-vars-mapping, SD.make-mutable-string-dict())
   end,
+  #|
   method _output(self):
     VS.vs-str(self.to-string())
   end
+  |#
 end
 
 check: