Allow @index operations to be deferred until runtime

Author: mkantor

src/end-to-end.test.ts

@@ -234,6 +234,17 @@ testCases(endToEnd, code => code)('end-to-end tests', [
       assert.deepEqual(typeof output.value['value'], 'string')
     },
   ],
+  [
+    `{@runtime context =>
+      :identity(:context).program.start_time
+    }`,
+    output => {
+      if (either.isLeft(output)) {
+        assert.fail(output.value.message)
+      }
+      assert(typeof output.value === 'string')
+    },
+  ],
   [
     `{@runtime context =>
       :context.environment.lookup(PATH)

src/language/compiling/semantics/keyword-handlers/index-handler.ts

@@ -4,6 +4,7 @@ import type { ElaborationError } from '../../../errors.js'
 import {
   applyKeyPathToSemanticGraph,
   asSemanticGraph,
+  containsAnyUnelaboratedNodes,
   keyPathFromObjectNodeOrMolecule,
   readIndexExpression,
   stringifyKeyPathForEndUser,
@@ -17,20 +18,31 @@ export const indexKeywordHandler: KeywordHandler = (
   expression: Expression,
   _context: ExpressionContext,
 ): Either<ElaborationError, SemanticGraph> =>
-  either.flatMap(readIndexExpression(expression), ({ object, query }) =>
-    either.flatMap(keyPathFromObjectNodeOrMolecule(query), keyPath =>
-      option.match(
-        applyKeyPathToSemanticGraph(asSemanticGraph(object), keyPath),
-        {
-          none: () =>
-            either.makeLeft({
-              kind: 'invalidExpression',
-              message: `property \`${stringifyKeyPathForEndUser(
-                keyPath,
-              )}\` not found`,
-            }),
-          some: either.makeRight,
-        },
-      ),
+  either.flatMap(readIndexExpression(expression), indexExpression =>
+    either.flatMap(
+      keyPathFromObjectNodeOrMolecule(indexExpression.query),
+      keyPath => {
+        if (containsAnyUnelaboratedNodes(indexExpression.object)) {
+          // The object isn't ready, so keep the @index unelaborated.
+          return either.makeRight(indexExpression)
+        } else {
+          return option.match(
+            applyKeyPathToSemanticGraph(
+              asSemanticGraph(indexExpression.object),
+              keyPath,
+            ),
+            {
+              none: () =>
+                either.makeLeft({
+                  kind: 'invalidExpression',
+                  message: `property \`${stringifyKeyPathForEndUser(
+                    keyPath,
+                  )}\` not found`,
+                }),
+              some: either.makeRight,
+            },
+          )
+        }
+      },
     ),
   )