Allow connecting providers and modules in components.

Author: gdotdesign

spec/compilers/connect_module

@@ -0,0 +1,21 @@
+module A {
+  fun value : String {
+    ""
+  }
+}
+
+component Main {
+  connect A exposing { value }
+
+  fun render {
+    value()
+  }
+}
+--------------------------------------------------------------------------------
+export const
+  a = () => {
+    return ``
+  },
+  A = () => {
+    return a()
+  };

spec/compilers/connect_provider

@@ -0,0 +1,31 @@
+type S {
+  a : String
+}
+
+provider A : S {
+  fun value : String {
+    ""
+  }
+}
+
+component Main {
+  connect A exposing { value }
+
+  fun render {
+    value()
+  }
+}
+--------------------------------------------------------------------------------
+import { createProvider as A } from "./runtime.js";
+
+export const
+  a = () => {
+    return ``
+  },
+  b = new Map(),
+  B = A(b, () => {
+    return null
+  }),
+  C = () => {
+    return a()
+  };

src/ls/definitions/connect_variable.cr

@@ -8,14 +8,12 @@ module Mint
                         @stack[1]?.as?(Ast::Connect)
 
         return unless store =
-                        @type_checker.artifacts.ast.stores
-                          .find(&.name.value.==(connect.store.value))
+                        @type_checker.artifacts.ast.unified_modules.find(&.name.value.==(connect.store.value)) ||
+                        @type_checker.artifacts.ast.providers.find(&.name.value.==(connect.store.value)) ||
+                        @type_checker.artifacts.ast.stores.find(&.name.value.==(connect.store.value))
 
         return unless target =
-                        store.functions.find(&.name.value.==(node.name.value)) ||
-                        store.constants.find(&.name.value.==(node.name.value)) ||
-                        store.states.find(&.name.value.==(node.name.value)) ||
-                        store.gets.find(&.name.value.==(node.name.value))
+                        @type_checker.artifacts.scope.resolve(node.name.value, store).try(&.node)
 
         case target
         when Ast::Function, Ast::State, Ast::Get, Ast::Constant

src/scope.cr

@@ -48,16 +48,18 @@ module Mint
     end
 
     # Resolves the targets which can be statically resolved, currently only
-    # the exposed variables of a connected store in a component.
+    # the exposed variables of a connected entity in a component.
     def resolve
       scopes.each do |node, stack|
         next unless node.is_a?(Ast::Component)
 
         node.connects.each do |connect|
-          case store = @ast.stores.find(&.name.value.==(connect.store.value))
-          when Ast::Store
+          if item =
+               @ast.unified_modules.find(&.name.value.==(connect.store.value)) ||
+               @ast.providers.find(&.name.value.==(connect.store.value)) ||
+               @ast.stores.find(&.name.value.==(connect.store.value))
             connect.keys.each do |key|
-              scopes[store][1].items[key.name.value]?.try do |value|
+              scopes[item][1].items[key.name.value]?.try do |value|
                 stack[1].items[key.target.try(&.value) || key.name.value] = value
               end
             end

src/type_checkers/connect.cr

@@ -2,7 +2,9 @@ module Mint
   class TypeChecker
     def check(node : Ast::Connect) : Checkable
       store =
-        ast.stores.find(&.name.value.==(node.store.value))
+        ast.unified_modules.find(&.name.value.==(node.store.value)) ||
+          ast.providers.find(&.name.value.==(node.store.value)) ||
+          ast.stores.find(&.name.value.==(node.store.value))
 
       error! :connect_not_found_store do
         block do