Corey's comments

Util/src/main/java/io/deephaven/util/MultiException.java

@@ -8,7 +8,7 @@
 import java.util.List;
 
 /**
- * An exception to use when a series of operations must all be executed, but may all throw exceptions themselves. This
+ * An exception to use when a series of operations mus all be executed, but may all throw exceptions themselves. This
  * allows for retention of all exception data.
  */
 public class MultiException extends Exception {

Util/src/main/java/io/deephaven/util/datastructures/CachingSupplier.java

@@ -17,7 +17,8 @@ public final class CachingSupplier<OUTPUT_TYPE> implements Supplier<OUTPUT_TYPE>
     private final Supplier<OUTPUT_TYPE> internalSupplier;
 
     private volatile boolean hasCachedResult;
-    private volatile OUTPUT_TYPE cachedResult;
+    private OUTPUT_TYPE cachedResult;
+    private RuntimeException errorResult;
 
     /**
      * Construct a {@link Supplier} wrapper.
@@ -33,12 +34,19 @@ public OUTPUT_TYPE get() {
         if (!hasCachedResult) {
             synchronized (this) {
                 if (!hasCachedResult) {
-                    cachedResult = internalSupplier.get();
+                    try {
+                        cachedResult = internalSupplier.get();
+                    } catch (RuntimeException err) {
+                        errorResult = err;
+                    }
                     hasCachedResult = true;
                 }
             }
         }
 
+        if (errorResult != null) {
+            throw errorResult;
+        }
         return cachedResult;
     }
 }

engine/table/src/main/java/io/deephaven/engine/table/impl/QueryCompilerRequestProcessor.java

@@ -3,17 +3,20 @@
  */
 package io.deephaven.engine.table.impl;
 
+import io.deephaven.UncheckedDeephavenException;
 import io.deephaven.engine.context.ExecutionContext;
 import io.deephaven.engine.context.QueryCompiler;
 import io.deephaven.engine.context.QueryCompilerRequest;
 import io.deephaven.engine.table.impl.perf.QueryPerformanceRecorder;
+import io.deephaven.util.MultiException;
 import io.deephaven.util.SafeCloseable;
 import io.deephaven.util.CompletionStageFuture;
 import io.deephaven.util.CompletionStageFutureImpl;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
 
 public interface QueryCompilerRequestProcessor {
     /**
@@ -80,12 +83,25 @@ public void compile() {
 
             try (final SafeCloseable ignored = QueryPerformanceRecorder.getInstance().getCompilationNugget(desc)) {
                 final QueryCompiler compiler = ExecutionContext.getContext().getQueryCompiler();
-                if (requests.size() == 1) {
-                    compiler.compile(requests.get(0), resolvers.get(0));
-                } else {
-                    compiler.compile(
-                            requests.toArray(QueryCompilerRequest[]::new),
-                            resolvers.toArray(CompletionStageFuture.Resolver[]::new));
+                // noinspection unchecked
+                compiler.compile(
+                        requests.toArray(QueryCompilerRequest[]::new),
+                        resolvers.toArray(CompletionStageFuture.Resolver[]::new));
+
+                final List<Throwable> exceptions = new ArrayList<>();
+                for (CompletionStageFuture.Resolver<Class<?>> resolver : resolvers) {
+                    try {
+                        Object ignored2 = resolver.getFuture().get();
+                    } catch (ExecutionException err) {
+                        exceptions.add(err.getCause());
+                    } catch (InterruptedException err) {
+                        exceptions.add(err);
+                    }
+                }
+                if (!exceptions.isEmpty()) {
+                    throw new UncheckedDeephavenException("Compilation failed",
+                            MultiException.maybeWrapInMultiException("Compilation exceptions for multiple requests",
+                                    exceptions));
                 }
             }
         }

engine/table/src/main/java/io/deephaven/engine/table/impl/select/AbstractFormulaColumn.java

@@ -286,8 +286,7 @@ protected Future<FormulaFactory> createKernelFormulaFactory(
         return formulaKernelFactoryFuture
                 .thenApply(formulaKernelFactory -> (columnName, rowSet, lazy, columnsToData, params) -> {
                     // Maybe warn that we ignore "lazy". By the way, "lazy" is the wrong term anyway. "lazy" doesn't
-                    // mean
-                    // "cached", which is how we are using it.
+                    // mean "cached", which is how we are using it.
                     final Map<String, ColumnSource<?>> netColumnSources = new HashMap<>();
                     for (final String sourceColumnName : sd.sources) {
                         final ColumnSource<?> columnSourceToUse = columnsToData.get(sourceColumnName);

engine/table/src/main/java/io/deephaven/engine/table/impl/select/analyzers/SelectAndViewAnalyzer.java

@@ -52,8 +52,8 @@ public enum Mode {
 
     public static Supplier<Map<String, Object>> newQueryScopeVariableSupplier() {
         final QueryScope queryScope = ExecutionContext.getContext().getQueryScope();
-        return new CachingSupplier<>(
-                () -> queryScope.toMap((name, value) -> NameValidator.isValidQueryParameterName(name)));
+        return new CachingSupplier<>(() -> Collections.unmodifiableMap(
+                queryScope.toMap((name, value) -> NameValidator.isValidQueryParameterName(name))));
     }
 
     public static void initializeSelectColumns(

open-api/lang-parser/lang-parser.gradle

@@ -10,6 +10,7 @@ plugins {
 apply from: "$rootDir/gradle/web-common.gradle"
 
 dependencies {
+    implementation project(':Util')
     api project(':open-api-shared-fu')
     implementation project(':log-factory')
     api project(':proto:proto-backplane-grpc')

open-api/lang-parser/src/main/java/io/deephaven/lang/parse/ParsedDocument.java

@@ -3,14 +3,14 @@
  */
 package io.deephaven.lang.parse;
 
-import io.deephaven.base.Lazy;
 import io.deephaven.base.verify.Assert;
 import io.deephaven.io.logger.Logger;
 import io.deephaven.lang.generated.*;
 import io.deephaven.proto.backplane.script.grpc.CompletionItem;
 import io.deephaven.proto.backplane.script.grpc.DocumentRange;
 import io.deephaven.proto.backplane.script.grpc.Position;
 import io.deephaven.proto.backplane.script.grpc.TextEdit;
+import io.deephaven.util.datastructures.CachingSupplier;
 import io.deephaven.web.shared.fu.MappedIterable;
 
 import java.util.*;
@@ -100,7 +100,7 @@ public boolean containsIndex(int i) {
     private static final Pattern NEW_LINE_PATTERN = Pattern.compile("\\r?\\n");
     private final ChunkerDocument doc;
 
-    private final Lazy<Set<ChunkerStatement>> statements;
+    private final CachingSupplier<Set<ChunkerStatement>> statements;
     private final String src;
     private String errorSource;
     private ParseException error;
@@ -112,7 +112,7 @@ public ParsedDocument(ChunkerDocument doc, String document) {
         this.src = document;
         computedPositions = new ConcurrentHashMap<>(4);
         assignments = new ConcurrentHashMap<>(12);
-        statements = new Lazy<>(() -> {
+        statements = new CachingSupplier<>(() -> {
             final LinkedHashSet<ChunkerStatement> stmts = new LinkedHashSet<>();
             doc.childrenAccept(new ChunkerDefaultVisitor() {
                 @Override

open-api/lang-tools/src/main/java/io/deephaven/lang/completion/CompletionLookups.java

@@ -3,11 +3,11 @@
  */
 package io.deephaven.lang.completion;
 
-import io.deephaven.base.Lazy;
 import io.deephaven.engine.context.ExecutionContext;
 import io.deephaven.engine.table.TableDefinition;
 import io.deephaven.engine.context.QueryLibrary;
 import io.deephaven.engine.util.ScriptSession;
+import io.deephaven.util.datastructures.CachingSupplier;
 
 import java.util.Collection;
 import java.util.Map;
@@ -26,15 +26,15 @@ public class CompletionLookups {
 
     private static final WeakHashMap<ScriptSession, CompletionLookups> lookups = new WeakHashMap<>();
 
-    private final Lazy<Collection<Class<?>>> statics;
+    private final CachingSupplier<Collection<Class<?>>> statics;
     private final Map<String, TableDefinition> referencedTables;
-    private final Lazy<CustomCompletion> customCompletions;
+    private final CachingSupplier<CustomCompletion> customCompletions;
 
     public CompletionLookups(Set<CustomCompletion.Factory> customCompletionFactory) {
         final QueryLibrary ql = ExecutionContext.getContext().getQueryLibrary();
-        statics = new Lazy<>(ql::getStaticImports);
+        statics = new CachingSupplier<>(ql::getStaticImports);
         referencedTables = new ConcurrentHashMap<>();
-        customCompletions = new Lazy<>(() -> new DelegatingCustomCompletion(customCompletionFactory));
+        customCompletions = new CachingSupplier<>(() -> new DelegatingCustomCompletion(customCompletionFactory));
 
         // This can be slow, so lets start it on a background thread right away.
         final ForkJoinPool pool = ForkJoinPool.commonPool();