Run Standard.Google in dual JVM mode

.vscode/launch.json

@@ -41,6 +41,16 @@
       "name": "Rust Gen CI",
       "program": "${workspaceFolder}/target/rust/debug/enso-build-ci-gen",
       "args": []
-    }
+    },
+   {
+      "type": "lldb",
+      "request": "launch",
+      "preLaunchTask": "Rust ./run",
+      "name": "Rust ./run",
+      "program": "${workspaceFolder}/target/rust/buildscript/enso-build-cli",
+      // provide arguments, for example: 
+      // "args": ["backend", "stdlib-api-check"]
+      "args": []
+    },
   ]
 }

.vscode/tasks.json

@@ -13,6 +13,19 @@
 				"isDefault": true
 			},
 			"label": "Rust Gen CI"
+		},
+		{
+			"type": "cargo",
+			"command": "build",
+			"args": ["--profile", "buildscript", "-p", "enso-build-cli"],
+			"problemMatcher": [
+				"$rustc"
+			],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"label": "Rust ./run"
 		}
 	]
 }

build.sbt

@@ -4063,9 +4063,6 @@ lazy val `engine-runner` = project
           `database-polyglot-root`
             .listFiles("*.jar")
             .map(_.getAbsolutePath()) ++
-          `google-polyglot-root`
-            .listFiles("*.jar")
-            .map(_.getAbsolutePath()) ++
           `std-aws-polyglot-root`.listFiles("*.jar").map(_.getAbsolutePath()) ++
           `std-snowflake-polyglot-root`
             .listFiles("*.jar")

build_tools/build/src/engine/context.rs

@@ -615,7 +615,8 @@ impl RunContext {
         assert!(old_api_dir.exists());
         debug!(
             "Checking API for library Standard.{}, its API dir is in {:?}",
-            lib.name, old_api_dir
+            lib.name,
+            self.short_path(&old_api_dir)
         );
         // `lib_path_in_built_distribution` points to the lib in the `built-distribution`
         // directory, which is not under VCS. We will regenerate the API in this directory
@@ -640,23 +641,27 @@ impl RunContext {
         match diff {
             Ok(_) => Ok(()),
             Err(err) => {
-                let suggested_cmd = built_enso
-                    .cmd()?
-                    .with_arg("--docs")
-                    .with_arg("api")
-                    .with_arg("--in-project")
-                    .with_arg(lib.path.clone());
                 error!("API check failed for library Standard.{}", lib.name);
                 error!("Current API vs Old API: {}", err);
-                error!("If you wish to overwrite the current API in the directory {}, run the following command {},
+                error!("If you wish to overwrite the current API in the directory {}, run the following command 
+                       sbt \"runEngineDistribution --no-ir-caches --docs=api --in-project {}\"
                        and commit the modified files",
-                  old_api_dir.display(),
-                  suggested_cmd.describe()
+                  self.short_path(&old_api_dir).display(),
+                  self.short_path(&lib.path).display()
                 );
                 bail!("API check failed for library Standard.{}", lib.name);
             }
         }
     }
+
+    fn short_path(&self, full: &Path) -> PathBuf {
+        let strip = full.strip_prefix(self.repo_root.path.clone());
+        if let Ok(relative) = strip {
+            relative.to_path_buf()
+        } else {
+            full.to_path_buf()
+        }
+    }
 }
 
 #[derive(Debug)]

distribution/lib/Standard/Base/0.0.0-dev/src/Enso_Cloud/Enso_Secret.enso

@@ -348,12 +348,12 @@ as_hideable_value (value : Text | Enso_Secret | Derived_Secret_Value) factory=Hi
    ---
    Used by library implementations to convert an Enso object into the Java
    counterpart.
-as_credential_reference (secret : Enso_Secret) -> CredentialReference =
+as_credential_reference (secret : Enso_Secret) credential_reference=CredentialReference =
     case secret.credential_metadata of
         Nothing ->
             Error.throw (Illegal_Argument.Error "Secret "+secret.name+" is not a credential.")
         metadata ->
-            CredentialReference.new secret.id metadata.service_name
+            credential_reference.new secret.id metadata.service_name
 
 ## ---
    private: true

distribution/lib/Standard/Google/0.0.0-dev/src/Google_Sheets_Workbook.enso

@@ -13,12 +13,14 @@ import Standard.Table.Internal.Java_Problems
 import Standard.Table.Return_As_Table.Return_As_Table
 import Standard.Table.Rows_To_Read.Rows_To_Read
 from Standard.Table import Column, Headers, Table
-from Standard.Table.Errors import Empty_Sheet, Invalid_Location, No_Rows
+from Standard.Table.Errors import Invalid_Location, No_Rows
 from Standard.Table.In_Memory_Table import from_java_table
 from Standard.Table.Internal.Table_Helpers import duplicate_rows
 
 import project.Internal.Telemetry
 
+polyglot java import org.enso.table.problems.ProblemAggregator
+polyglot java import org.enso.base.enso_cloud.ExternalLibraryCredentialHelper.CredentialReference
 polyglot java import com.google.api.client.googleapis.json.GoogleJsonResponseException
 polyglot java import org.enso.google.GoogleSheetsForEnso
 polyglot java import org.enso.google.GoogleSheetsHeaders.HeaderBehavior
@@ -65,7 +67,7 @@ type Google_Sheets_Workbook
     read self query:(Text|Integer) headers:Headers=..Detect_Headers limit:Rows_To_Read=..All_Rows skip_rows:Integer=0 on_problems:Problem_Behavior=..Report_Warning -> Table =
         java_headers = _make_java_headers headers
         java_limit = limit.rows_to_read
-        java_table = Java_Problems.with_problem_aggregator on_problems java_problem_aggregator-> _handle_exceptions <|
+        java_table = Java_Problems.with_problem_aggregator on_problems problem_aggregator=ProblemAggregator java_problem_aggregator-> _handle_exceptions <|
             case query of
                 _ : Text -> self.java_service.getSheetRange self.workbook_id query java_headers java_limit skip_rows java_problem_aggregator
                 _ : Integer ->
@@ -167,14 +169,14 @@ type Google_API_Error
     to_display_text self =
         self.details.at 'message'
 
-private _handle_exceptions ~action = Empty_Sheet.handle_java_exception <|
+private _handle_exceptions ~action =
     Panic.catch GoogleJsonResponseException action caught_panic->
         Error.throw (Google_API_Error.Error caught_panic.payload.getContent.parse_json)
 
 private _wrap_credentials credential:(File|Enso_Secret|Nothing)=Nothing =
     case credential of
         secret : Enso_Secret ->
-            WrappedGoogleCredentials.fromCredentialReference (as_credential_reference secret)
+            WrappedGoogleCredentials.fromCredentialReference (as_credential_reference secret CredentialReference)
         secret_file : File ->
             secret_file.with_input_stream [File_Access.Read] stream->
                 stream.with_java_stream java_input_stream->

distribution/lib/Standard/Table/0.0.0-dev/src/Errors.enso

@@ -7,7 +7,6 @@ import project.Value_Type.Value_Type
 polyglot java import org.enso.table.error.ColumnCountMismatchException
 polyglot java import org.enso.table.error.ColumnNameMismatchException
 polyglot java import org.enso.table.error.EmptyFileException
-polyglot java import org.enso.table.error.EmptySheetException
 polyglot java import org.enso.table.error.InvalidColumnNameException
 polyglot java import org.enso.table.read.FixedWidthLineTooLongException
 polyglot java import org.enso.table.read.NoColumnNamesFoundException
@@ -421,7 +420,7 @@ type Empty_Sheet
        private: true
        ---
     handle_java_exception =
-        Panic.catch EmptySheetException handler=(_ -> Error.throw Empty_Sheet.Error)
+        Panic.recover Empty_Sheet
 
 ## Indicates that the column was already present in the table.
 type Existing_Column

distribution/lib/Standard/Table/0.0.0-dev/src/In_Memory_Table.enso

@@ -1,4 +1,5 @@
 from Standard.Base import all
+from Standard.Base.Logging import all
 import Standard.Base.Data.Vector.No_Wrap
 import Standard.Base.Errors.Deprecated.Deprecated
 import Standard.Base.Errors.Illegal_Argument.Illegal_Argument
@@ -18,6 +19,7 @@ import project.Table.Table
 from project.Internal.Table_Type_Helpers import table_from_implementation
 
 polyglot java import org.enso.table.data.column.DataQualityMetrics
+polyglot java import org.enso.table.data.table.Column as Java_Column
 polyglot java import org.enso.table.data.table.Table as Java_Table
 
 ## A table whose data is stored in memory.
@@ -35,9 +37,14 @@ type In_Memory_Table
     ## ---
        private: true
        ---
-       A getter that is a workaround for bug
-       https://github.com/enso-org/enso/issues/12180
-    private java_table self = self.internal_java_table
+       A getter that allows one to specify the target Java type and handles
+       conversions when needed
+    private java_table self table_class=Java_Table column_class=Java_Column =
+        raw_table = self.internal_java_table
+        if raw_table.is_a table_class then raw_table else
+            # coming from the other JVM and deserves conversion
+            new_columns = raw_table.getColumns.map c-> column_class.new c.getName c.getStorage
+            table_class.new new_columns
 
     ## ---
        private: true
@@ -88,7 +95,12 @@ type In_Memory_Table
    Helper method for internal use to make a Table from a Java Table.
 from_java_table java_table =
     ## Trigger data quality metrics computation (conditionally on Output context).
-    if Context.Output.is_enabled.not then DataQualityMetrics.triggerTable java_table
+    if Context.Output.is_enabled.not then
+        case java_table of
+            _:Java_Table ->
+                DataQualityMetrics.triggerTable java_table
+            _ ->
+                In_Memory_Table.log_message "Cannot compute DataQualityMetrics for "+java_table.to_text
 
     Table_Refinements.refine_table <|
         In_Memory_Table.Value java_table

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/In_Memory_Table_Implementation.enso

@@ -553,7 +553,9 @@ type In_Memory_Table_Implementation
             [Row_Count_Mismatch.Error left_row_count right_row_count]
         on_problems.attach_problems_before problems <|
             new_java_table = Java_Problems.with_problem_aggregator on_problems java_aggregator->
-                (this_table:In_Memory_Table).java_table.zip (right:In_Memory_Table).java_table keep_unmatched_bool right_prefix java_aggregator
+                this_java_table = (this_table:In_Memory_Table).java_table
+                right_java_table = (right:In_Memory_Table).java_table
+                this_java_table.zip right_java_table keep_unmatched_bool right_prefix java_aggregator
             from_java_table new_java_table
 
     union (this_table : Table & In_Memory_Table) (tables : Table | Vector) columns_to_keep:Columns_To_Keep match_columns:Match_Columns on_problems:Problem_Behavior =

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Java_Problems.enso

@@ -13,6 +13,10 @@ polyglot java import org.enso.table.data.column.builder.LossOfBigDecimalPrecisio
 polyglot java import org.enso.table.data.column.builder.LossOfIntegerPrecision
 polyglot java import org.enso.table.data.column.operation.cast.ConversionFailure
 polyglot java import org.enso.table.data.column.operation.cast.ConversionFailureType
+
+# reflection access to various class methods and fields 
+# is being performed on problem classes, hence listing them here
+# so EnsoLibraryFeature registers them for reflection
 polyglot java import org.enso.table.data.table.problems.ArithmeticError
 polyglot java import org.enso.table.data.table.problems.ArithmeticOverflow
 polyglot java import org.enso.table.data.table.problems.FloatingPointGrouping
@@ -37,31 +41,31 @@ polyglot java import org.enso.table.util.problems.InvalidNames
    private: true
    ---
    Convert a Java problem into its Enso equivalent.
-translate_problem p = case p of
-    _ : InvalidAggregation ->
+translate_problem p = case p.problemType of
+    "InvalidAggregation" ->
         err = Invalid_Aggregation.Error p.getLocationName (Vector.from_polyglot_array p.getRows) p.getMessage
         Error.throw err
-    _ : ArithmeticError ->
+    "ArithmeticError" ->
         Arithmetic_Error.Error p.getMessage
-    _ : IllegalArgumentError ->
+    "IllegalArgumentError" ->
         Illegal_Argument.Error p.getMessage
-    _ : IgnoredNaN ->
+    "IgnoredNaN" ->
         Ignored_NaN_Values.Warning p.getLocationName (Vector.from_polyglot_array p.getRows)
-    _ : IgnoredNothing ->
+    "IgnoredNothing" ->
         Ignored_Nothing_Values.Warning p.getLocationName (Vector.from_polyglot_array p.getRows)
-    _ : FloatingPointGrouping ->
+    "FloatingPointGrouping" ->
         Floating_Point_Equality.Error p.getLocationName
-    _ : LossOfIntegerPrecision ->
+    "LossOfIntegerPrecision" ->
         Loss_Of_Integer_Precision.Warning p.getAffectedRowsCount p.getExampleValue p.getExampleValueConverted
-    _ : LossOfBigDecimalPrecision ->
+    "LossOfBigDecimalPrecision" ->
         Loss_Of_Decimal_Precision.Warning p.getAffectedRowsCount (java_to_enso p.getExampleValue) p.getExampleValueConverted
-    _ : ArithmeticOverflow ->
+    "ArithmeticOverflow" ->
         target_type = Storage.to_value_type p.targetType
         example_operands = case p.exampleOperands of
             Nothing -> Nothing
             array -> Vector.from_polyglot_array array
         Arithmetic_Overflow.Warning target_type p.affectedRowCount example_operands
-    _ : ConversionFailure ->
+    "ConversionFailure" ->
         examples = Vector.from_polyglot_array p.examples
         target_type = Storage.to_value_type p.targetType
         related_column = p.relatedColumn
@@ -70,23 +74,23 @@ translate_problem p = case p of
             if p.errorType == ConversionFailureType.TEXT_TOO_LONG then Conversion_Failure.Text_Too_Long else
                 Conversion_Failure.Error
         constructor target_type related_column affected_rows_count examples
-    _ : UnquotedCharactersInOutput ->
+    "UnquotedCharactersInOutput" ->
         Unquoted_Characters_In_Output.Warning p.getLocationName (Vector.from_polyglot_array p.getRows)
-    _ : UnquotedDelimiter ->
+    "UnquotedDelimiter" ->
         Unquoted_Delimiter.Error p.getLocationName (Vector.from_polyglot_array p.getRows)
-    _ : InvalidRow ->
+    "InvalidRow" ->
         Invalid_Row.Error p.source_row p.table_index (Vector.from_polyglot_array p.row) p.expected_length
-    _ : InvalidFixedWidthRow ->
+    "InvalidFixedWidthRow" ->
         Invalid_Fixed_Width_Row.Error p.source_line_number p.table_row_number p.line_length p.minimum_line_length
-    _ : InconsistentFixedWidthLengths ->
+    "InconsistentFixedWidthLengths" ->
         Inconsistent_Fixed_Width_Lengths.Error
-    _ : AdditionalInvalidRows ->
+    "AdditionalInvalidRows" ->
         Additional_Invalid_Rows.Error p.count
-    _ : DuplicateNames ->
+    "DuplicateNames" ->
         Duplicate_Output_Column_Names.Error (Vector.from_polyglot_array p.duplicatedNames)
-    _ : InvalidNames ->
+    "InvalidNames" ->
         Invalid_Column_Names.Error (Vector.from_polyglot_array p.invalidNames)
-    _ : InvalidFormat ->
+    "InvalidFormat" ->
         Invalid_Format.Error p.column p.expectedEnsoValueType p.count (Vector.from_polyglot_array p.cells)
     _ ->
         Panic.throw (Illegal_Argument.Error "Encountered an unknown problem type when converting Java problems into Enso. This is a bug in the Table library. The unexpected problem was: "+p.to_text)

engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/JavaPolyglotNode.java

@@ -4,15 +4,26 @@
 import com.oracle.truffle.api.nodes.RootNode;
 import java.io.IOException;
 import java.net.URISyntaxException;
+import java.util.function.Function;
 import org.enso.jvm.interop.api.OtherJvmClassLoader;
 
 final class JavaPolyglotNode {
   static GenericForeignNode create(EpbContext context) {
     try {
       var isAot = TruffleOptions.AOT;
+      Function<String, Object> polyglotBindings =
+          (name) -> {
+            var lang = context.getEnv().getInternalLanguages().get(name);
+            return lang == null ? null : context.getEnv().getScopePublic(lang);
+          };
+      assert null != polyglotBindings;
       var loader =
           OtherJvmClassLoader.create(
-              "org.enso.jvm.interop", EpbLanguage.class, isAot, context.getEnv().getContext());
+              "org.enso.jvm.interop",
+              EpbLanguage.class,
+              polyglotBindings,
+              isAot,
+              context.getEnv().getContext());
       var target = RootNode.createConstantNode(loader).getCallTarget();
       return new GenericForeignNode(target);
     } catch (URISyntaxException | IOException ex) {

engine/runtime/src/main/java/org/enso/interpreter/runtime/EnsoPolyglotJava.java

@@ -158,10 +158,19 @@ static void close(EnsoContext ctx) {
   private Object findPolyglotJava() throws InteropException {
     TruffleSafepoint.setBlockedThreadInterruptible(null, Semaphore::acquire, lock);
     try {
+      if (polyglotJava instanceof Throwable t) {
+        throw ctx.raiseAssertionPanic(null, t.getMessage(), t);
+      }
       if (polyglotJava != this) {
         return polyglotJava;
       }
-      polyglotJava = createPolyglotJava(ctx);
+      try {
+        polyglotJava = createPolyglotJava(ctx);
+      } catch (Throwable t) {
+        logger.log(Level.ERROR, "Cannot initialize", t);
+        polyglotJava = t;
+        throw t;
+      }
       while (!pendingPath.isEmpty()) {
         InteropLibrary.getUncached()
             .invokeMember(polyglotJava, "addPath", pendingPath.remove(0).toString());
@@ -246,7 +255,7 @@ private Object createPolyglotJava(EnsoContext ctx) throws IllegalStateException
     } else {
       var envJava = System.getenv("ENSO_JAVA");
       if (envJava == null) {
-        logger.log(Level.ERROR, "Using experimental OtherJvm support!");
+        logger.log(Level.INFO, "Initializing OtherJvm support!");
         var src = Source.newBuilder("epb", "java:0#guest", "<Bindings>").build();
         var target = ctx.parseInternal(src);
         return target.call();

engine/runtime/src/main/java/org/enso/interpreter/runtime/error/DataflowError.java

@@ -114,7 +114,7 @@ private DataflowError(Object payload, AbstractTruffleException prototype) {
     super(prototype);
     this.payload = payload;
     this.ownTrace = false;
-    this.ctx = prototype instanceof PanicException panic ? panic.ctx() : null;
+    this.ctx = prototype instanceof PanicException panic ? panic.ctx() : EnsoContext.get(null);
   }
 
   private DataflowError(Object payload, int stackTraceElementLimit, Node location) {
@@ -217,7 +217,7 @@ boolean isNull() {
 
   @ExportMessage
   RuntimeException throwException() throws UnsupportedMessageException {
-    return this;
+    return new PanicException(this);
   }
 
   @ExportMessage