Allow capabilities to be referenced before they're defined

source/crochet/crochet.ts

@@ -228,6 +228,7 @@ export class BootedCrochet {
 
     VM.Types.verify_package_types(cpkg);
     VM.Types.verify_package_traits(cpkg);
+    VM.Capability.verify_package_capabilities(cpkg);
   }
 
   private reify_capability_grants(pkg: Package.ResolvedPackage) {

source/vm/boot.ts

@@ -721,12 +721,26 @@ export function load_declaration(
     }
 
     case t.CAPABILITY: {
-      const capability = new CrochetCapability(
+      const new_capability = new CrochetCapability(
         module,
         declaration.name,
         declaration.documentation,
         declaration.meta
       );
+      let capability;
+      const missing = Capability.try_get_placeholder_capability(
+        module,
+        declaration.name
+      );
+      if (missing != null) {
+        capability = Capability.fulfill_placeholder_capability(
+          module,
+          missing,
+          new_capability
+        );
+      } else {
+        capability = new_capability;
+      }
       Capability.define_capability(module, capability);
       break;
     }

source/vm/intrinsics.ts

@@ -364,6 +364,7 @@ export class CrochetWorld {
 export class CrochetPackage {
   readonly missing_traits: Namespace<CrochetTrait>;
   readonly missing_types: Namespace<CrochetType>;
+  readonly missing_capabilities: Namespace<CrochetCapability>;
   readonly types: PassthroughNamespace<CrochetType>;
   readonly traits: PassthroughNamespace<CrochetTrait>;
   readonly definitions: PassthroughNamespace<CrochetValue>;
@@ -382,6 +383,7 @@ export class CrochetPackage {
   ) {
     this.missing_traits = new Namespace(null, null, null);
     this.missing_types = new Namespace(null, null, null);
+    this.missing_capabilities = new Namespace(null, null, null);
     this.types = new PassthroughNamespace(world.types, name);
     this.traits = new PassthroughNamespace(world.traits, name);
     this.definitions = new PassthroughNamespace(world.definitions, name);

source/vm/primitives/capability.ts

@@ -1,6 +1,7 @@
 import {
   CrochetCapability,
   CrochetModule,
+  CrochetPackage,
   CrochetTrait,
   CrochetType,
   CrochetValue,
@@ -31,13 +32,70 @@ export function define_capability(
 
 export function get_capability(module: CrochetModule, name: string) {
   const capability = module.pkg.capabilities.try_lookup(name);
-  if (capability == null) {
+  if (capability != null) {
+    return capability;
+  }
+
+  const missing = module.pkg.missing_capabilities.try_lookup(name);
+  if (missing != null) {
+    return missing;
+  }
+
+  const placeholder = make_placeholder_capability(module, name);
+  module.pkg.missing_capabilities.define(name, placeholder);
+  return placeholder;
+}
+
+export function make_placeholder_capability(
+  module: CrochetModule,
+  name: string
+) {
+  return new CrochetCapability(module, name, "(placeholder capability)", null);
+}
+
+export function try_get_placeholder_capability(
+  module: CrochetModule,
+  name: string
+) {
+  return module.pkg.missing_capabilities.try_lookup(name);
+}
+
+export function fulfill_placeholder_capability(
+  module: CrochetModule,
+  placeholder: CrochetCapability,
+  capability: CrochetCapability
+) {
+  const value = module.pkg.missing_capabilities.try_lookup(capability.name);
+  if (value !== placeholder) {
+    throw new ErrArbitrary(
+      "internal",
+      `Invalid placeholder for ${capability.name}`
+    );
+  }
+
+  module.pkg.missing_capabilities.remove(capability.name);
+  const p: { -readonly [k in keyof typeof capability]: typeof capability[k] } =
+    placeholder;
+  p.protecting = capability.protecting;
+  p.module = capability.module;
+  p.name = capability.name;
+  p.documentation = capability.documentation;
+  p.meta = capability.meta;
+
+  return p;
+}
+
+export function verify_package_capabilities(pkg: CrochetPackage) {
+  if (pkg.missing_capabilities.own_bindings.size > 0) {
     throw new ErrArbitrary(
-      "undefined-capability",
-      `The capability ${name} is not defined in package ${module.pkg.name}`
+      "internal",
+      `Package ${
+        pkg.name
+      } cannot be loaded because it's missing the following capability definitions: ${[
+        ...pkg.missing_capabilities.own_bindings.keys(),
+      ].join(", ")}`
     );
   }
-  return capability;
 }
 
 export function protect_type(

tests/vm-tests/capabilities.crochet

@@ -0,0 +1,7 @@
+% crochet
+
+// We can refer to capabilities before they're defined
+type capability-protected;
+protect type capability-protected with protecc;
+
+capability protecc;

tests/vm-tests/crochet.json

@@ -30,7 +30,8 @@
     "actions.crochet",
     "effects.crochet",
     "dsl.crochet",
-    "traits.crochet"
+    "traits.crochet",
+    "capabilities.crochet"
   ],
   "capabilities": {
     "requires": ["crochet.debug/internal"],