enso-org/enso
1
1
Fork 0
mirror of https://github.com/enso-org/enso.git synced 2024-12-22 22:21:40 +03:00
Code Issues Projects Releases Wiki Activity

Enable asserts in the tests (#4074)

Browse Source 
Enso unit tests were running without `-ea` check enabled and as such various invariant checks in Truffle code were not executed. Let's turn the `-ea` flag on and fix all the code misbehaves.
This commit is contained in:
Jaroslav Tulach 2023-01-26 22:41:35 +01:00 committed by GitHub
parent ad6419f204
commit ca2f108513
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 292 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
build.sbt
View File

@ -1106,7 +1106,7 @@ lazy val `interpreter-dsl` = (project in file("lib/scala/interpreter-dsl"))
// === Sub-Projects ===========================================================
// ============================================================================
val truffleRunOptions = if (java.lang.Boolean.getBoolean("bench.compileOnly")) {
val truffleRunOptionsNoAssert = if (java.lang.Boolean.getBoolean("bench.compileOnly")) {
Seq(
"-Dpolyglot.engine.IterativePartialEscape=true",
"-Dpolyglot.engine.BackgroundCompilation=false",
@ -1118,6 +1118,12 @@ val truffleRunOptions = if (java.lang.Boolean.getBoolean("bench.compileOnly")) {
"-Dpolyglot.engine.BackgroundCompilation=false"
)
}
val truffleRunOptions = "-ea" +: truffleRunOptionsNoAssert
val truffleRunOptionsNoAssertSettings = Seq(
fork := true,
javaOptions ++= truffleRunOptionsNoAssert
)
val truffleRunOptionsSettings = Seq(
fork := true,
@ -1127,6 +1133,7 @@ val truffleRunOptionsSettings = Seq(
lazy val `polyglot-api` = project
.in(file("engine/polyglot-api"))
.settings(
frgaalJavaCompilerSetting,
Test / fork := true,
commands += WithDebugCommand.withDebug,
Test / envVars ++= distributionEnvironmentOverrides,
@ -1180,6 +1187,7 @@ lazy val `language-server` = (project in file("engine/language-server"))
)
.configs(Benchmark)
.settings(
inConfig(Compile)(truffleRunOptionsSettings),
inConfig(Benchmark)(Defaults.testSettings),
bench := (Benchmark / test).value,
libraryDependencies += "com.storm-enroute" %% "scalameter" % scalameterVersion % "bench",
@ -1575,7 +1583,7 @@ lazy val `runtime-with-polyglot` =
.configs(Benchmark)
.settings(
frgaalJavaCompilerSetting,
inConfig(Compile)(truffleRunOptionsSettings),
inConfig(Compile)(truffleRunOptionsNoAssertSettings),
inConfig(Benchmark)(Defaults.testSettings),
commands += WithDebugCommand.withDebug,
Benchmark / javacOptions --= Seq(

27
engine/runtime-with-instruments/src/test/java/org/enso/interpreter/test/instrument/AvoidIdInstrumentationTagTest.java
View File

@ -1,11 +1,9 @@
package org.enso.interpreter.test.instrument;
import com.oracle.truffle.api.instrumentation.InstrumentableNode;
import com.oracle.truffle.api.instrumentation.StandardTags;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.source.SourceSection;
import java.io.OutputStream;
import java.nio.file.Paths;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import org.enso.interpreter.node.ClosureRootNode;
@ -14,39 +12,36 @@ import org.enso.interpreter.runtime.tag.IdentifiedTag;
import org.enso.interpreter.test.NodeCountingTestInstrument;
import org.enso.polyglot.RuntimeOptions;
import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Engine;
import org.graalvm.polyglot.Language;
import org.graalvm.polyglot.Source;
import org.junit.After;
import org.junit.Assert;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.fail;
import org.junit.Before;
import org.junit.Test;
public class AvoidIdInstrumentationTagTest {
private Engine engine;
private Context context;
private NodeCountingTestInstrument nodes;
@Before
public void initContext() {
engine = Engine.newBuilder()
context = Context.newBuilder()
.allowExperimentalOptions(true)
.option(
RuntimeOptions.LANGUAGE_HOME_OVERRIDE,
Paths.get("../../distribution/component").toFile().getAbsolutePath()
)
.logHandler(OutputStream.nullOutputStream())
.build();
context = Context.newBuilder()
.engine(engine)
.allowExperimentalOptions(true)
.allowIO(true)
.allowAllAccess(true)
.build();
var engine = context.getEngine();
Map<String, Language> langs = engine.getLanguages();
Assert.assertNotNull("Enso found: " + langs, langs.get("enso"));
@ -57,26 +52,26 @@ public class AvoidIdInstrumentationTagTest {
@After
public void disposeContext() {
context.close();
engine.close();
}
@Test
public void avoidIdInstrumentationInLambdaMapFunctionWithNoise() {
public void avoidIdInstrumentationInLambdaMapFunctionWithNoise() throws Exception {
var code = """
from Standard.Base import all
import Standard.Visualization
run n = 0.up_to n . map i-> 1.noise * i
""";
var module = context.eval("enso", code);
var src = Source.newBuilder("enso", code, "TestLambda.enso").build();
var module = context.eval(src);
var run = module.invokeMember("eval_expression", "run");
var res = run.execute(10000);
assertEquals("Array of the requested size computed", 10000, res.getArraySize());
Predicate<SourceSection> isLambda = (ss) -> {
var sameSrc = ss.getSource().getCharacters().toString().equals(src.getCharacters().toString());
var st = ss.getCharacters().toString();
return st.contains("noise") && !st.contains("map");
return sameSrc && st.contains("noise") && !st.contains("map");
};
assertAvoidIdInstrumentationTag(isLambda);
@ -86,6 +81,7 @@ public class AvoidIdInstrumentationTagTest {
var found = nodes.assertNewNodes("Give me nodes", 0, 10000);
var err = new StringBuilder();
var missingTagInLambda = false;
var count = 0;
for (var nn : found.values()) {
for (var n : nn) {
var ss = n.getSourceSection();
@ -98,6 +94,8 @@ public class AvoidIdInstrumentationTagTest {
final boolean hasAvoidIdInstrumentationTag = in.hasTag(AvoidIdInstrumentationTag.class);
if (!hasAvoidIdInstrumentationTag) {
missingTagInLambda = true;
} else {
count++;
}
err.append("\n").append(" AvoidIdInstrumentationTag: ").append(hasAvoidIdInstrumentationTag);
@ -115,5 +113,6 @@ public class AvoidIdInstrumentationTagTest {
if (missingTagInLambda) {
fail(err.toString());
}
assertNotEquals("Found some nodes", 0, count);
}
}

2
engine/runtime/src/main/java/org/enso/interpreter/node/EnsoRootNode.java
View File

@ -4,6 +4,7 @@ import com.oracle.truffle.api.nodes.NodeInfo;
import com.oracle.truffle.api.nodes.RootNode;
import com.oracle.truffle.api.source.Source;
import com.oracle.truffle.api.source.SourceSection;
import java.util.Objects;
import org.enso.interpreter.EnsoLanguage;
import org.enso.interpreter.runtime.EnsoContext;
import org.enso.interpreter.runtime.scope.LocalScope;
@ -35,6 +36,7 @@ public abstract class EnsoRootNode extends RootNode {
String name,
SourceSection sourceSection) {
super(language, localScope.frameDescriptor());
Objects.requireNonNull(language);
this.name = name;
this.localScope = localScope;
this.moduleScope = moduleScope;

5
engine/runtime/src/main/java/org/enso/interpreter/node/ExpressionNode.java
View File

@ -191,7 +191,10 @@ public abstract class ExpressionNode extends BaseNode implements InstrumentableN
if (AvoidIdInstrumentationTag.class == tag) {
return getRootNode() instanceof ClosureRootNode c && !c.isSubjectToInstrumentation();
}
return tag == StandardTags.ExpressionTag.class || (tag == IdentifiedTag.class && id != null);
if (tag == StandardTags.ExpressionTag.class) {
return getSourceSection() != null;
}
return tag == IdentifiedTag.class && id != null;
}
/**

25
engine/runtime/src/main/java/org/enso/interpreter/node/callable/function/BlockNode.java
View File

@ -7,6 +7,7 @@ import com.oracle.truffle.api.instrumentation.StandardTags;
import com.oracle.truffle.api.instrumentation.Tag;
import com.oracle.truffle.api.nodes.ExplodeLoop;
import com.oracle.truffle.api.nodes.NodeInfo;
import com.oracle.truffle.api.source.SourceSection;
import java.util.Set;
import org.enso.interpreter.node.ExpressionNode;
import org.enso.interpreter.runtime.EnsoContext;
@ -65,14 +66,6 @@ public class BlockNode extends ExpressionNode {
public InstrumentableNode materializeInstrumentableNodes(
Set<Class<? extends Tag>> materializedTags) {
if (materializedTags.contains(StandardTags.StatementTag.class)) {
var ctx = EnsoContext.get(this);
if (ctx != null) {
Assumption chromeInspectorNotAttached = ctx.getChromeInspectorNotAttached();
if (chromeInspectorNotAttached.isValid()
&& ctx.getEnvironment().getInstruments().containsKey("inspect")) {
chromeInspectorNotAttached.invalidate("Chrome inspector attached");
}
}
for (int i = 0; i < statements.length; i++) {
if (!isNodeWrapped(statements[i])) {
statements[i] = insert(StatementNode.wrap(statements[i]));
@ -89,10 +82,20 @@ public class BlockNode extends ExpressionNode {
return node instanceof StatementNode || ExpressionNode.isWrapper(node);
}
@Override
public SourceSection getSourceSection() {
var ss = super.getSourceSection();
return ss != null ? ss : getRootNode().getSourceSection();
}
@Override
public boolean hasTag(Class<? extends Tag> tag) {
return super.hasTag(tag)
|| tag == StandardTags.RootBodyTag.class
|| tag == StandardTags.RootTag.class;
if (super.hasTag(tag)) {
return true;
}
if (tag == StandardTags.RootBodyTag.class || tag == StandardTags.RootTag.class) {
return true;
}
return false;
}
}

11
engine/runtime/src/main/java/org/enso/interpreter/node/callable/function/StatementNode.java
View File

@ -1,11 +1,14 @@
package org.enso.interpreter.node.callable.function;
import com.oracle.truffle.api.Assumption;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.instrumentation.StandardTags;
import com.oracle.truffle.api.instrumentation.Tag;
import com.oracle.truffle.api.source.SourceSection;
import org.enso.interpreter.node.ClosureRootNode;
import org.enso.interpreter.node.ExpressionNode;
import org.enso.interpreter.runtime.EnsoContext;
import org.enso.interpreter.runtime.tag.AvoidIdInstrumentationTag;
/**
@ -39,6 +42,14 @@ final class StatementNode extends ExpressionNode {
@Override
public Object executeGeneric(VirtualFrame frame) {
if (CompilerDirectives.inInterpreter()) {
var ctx = EnsoContext.get(this);
Assumption chromeInspectorNotAttached = ctx.getChromeInspectorNotAttached();
if (chromeInspectorNotAttached.isValid()
&& ctx.getEnvironment().getInstruments().containsKey("inspect")) {
chromeInspectorNotAttached.invalidate("Chrome inspector attached");
}
}
return node.executeGeneric(frame);
}

8
engine/runtime/src/main/java/org/enso/interpreter/node/controlflow/caseexpr/BranchResult.java
View File

@ -1,15 +1,15 @@
package org.enso.interpreter.node.controlflow.caseexpr;
import com.oracle.truffle.api.interop.TruffleObject;
import com.oracle.truffle.api.nodes.Node;
import org.enso.interpreter.runtime.EnsoContext;
public record BranchResult(boolean isMatched, Object result) {
public static BranchResult failure(Node node) {
record BranchResult(boolean isMatched, Object result) implements TruffleObject {
static BranchResult failure(Node node) {
return new BranchResult(false, EnsoContext.get(node).getBuiltins().nothing());
}
public static BranchResult success(Object result) {
static BranchResult success(Object result) {
return new BranchResult(true, result);
}

7
engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/Builtin.java
View File

@ -19,10 +19,9 @@ public abstract class Builtin {
this(name, Arrays.asList(params));
}
private AtomConstructor build(ModuleScope scope, Type type) {
private AtomConstructor build(EnsoLanguage language, ModuleScope scope, Type type) {
var res = new AtomConstructor(name, scope, type,true);
res.initializeFields(
IntStream.range(0, params.size())
res.initializeFields(language, IntStream.range(0, params.size())
.mapToObj(
i ->
new ArgumentDefinition(
@ -66,7 +65,7 @@ public abstract class Builtin {
var conses = getDeclaredConstructors();
constructors = new AtomConstructor[conses.size()];
for (int i = 0; i < constructors.length; i++) {
var cons = conses.get(i).build(scope, type);
var cons = conses.get(i).build(language, scope, type);
constructors[i] = cons;
type.registerConstructor(cons);
}

79
engine/runtime/src/main/java/org/enso/interpreter/runtime/EnsoContext.java
View File

@ -1,14 +1,14 @@
package org.enso.interpreter.runtime;
import com.oracle.truffle.api.Assumption;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.Truffle;
import com.oracle.truffle.api.TruffleFile;
import com.oracle.truffle.api.TruffleLanguage;
import com.oracle.truffle.api.TruffleLanguage.Env;
import com.oracle.truffle.api.TruffleLogger;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.object.Shape;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;
import org.enso.compiler.Compiler;
import org.enso.compiler.PackageRepository;
import org.enso.compiler.data.CompilerConfig;
@ -18,6 +18,7 @@ import org.enso.editions.LibraryName;
import org.enso.interpreter.EnsoLanguage;
import org.enso.interpreter.OptionsHelper;
import org.enso.interpreter.instrument.NotificationHandler;
import org.enso.interpreter.runtime.Module;
import org.enso.interpreter.runtime.builtin.Builtins;
import org.enso.interpreter.runtime.data.Type;
import org.enso.interpreter.runtime.scope.TopLevelScope;
@ -31,12 +32,20 @@ import org.enso.pkg.PackageManager;
import org.enso.pkg.QualifiedName;
import org.enso.polyglot.LanguageInfo;
import org.enso.polyglot.RuntimeOptions;
import scala.jdk.javaapi.OptionConverters;
import org.enso.polyglot.RuntimeServerInfo;
import org.graalvm.options.OptionKey;
import java.io.*;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;
import com.oracle.truffle.api.Assumption;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.Truffle;
import com.oracle.truffle.api.TruffleFile;
import com.oracle.truffle.api.TruffleLanguage;
import com.oracle.truffle.api.TruffleLanguage.Env;
import com.oracle.truffle.api.TruffleLogger;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.object.Shape;
import scala.jdk.javaapi.OptionConverters;
/**
* The language context is the internal state of the language that is associated with each thread in
@ -101,21 +110,19 @@ public class EnsoContext {
this.inReader = new BufferedReader(new InputStreamReader(environment.in()));
this.threadManager = new ThreadManager(environment);
this.resourceManager = new ResourceManager(this);
this.isInlineCachingDisabled =
environment.getOptions().get(RuntimeOptions.DISABLE_INLINE_CACHES_KEY);
var isParallelismEnabled =
environment.getOptions().get(RuntimeOptions.ENABLE_AUTO_PARALLELISM_KEY);
this.isInlineCachingDisabled = getOption(RuntimeOptions.DISABLE_INLINE_CACHES_KEY);
var isParallelismEnabled = getOption(RuntimeOptions.ENABLE_AUTO_PARALLELISM_KEY);
this.isIrCachingDisabled =
environment.getOptions().get(RuntimeOptions.DISABLE_IR_CACHES_KEY) || isParallelismEnabled;
this.rootIOPermissions = environment.getOptions().get(EnsoLanguage.IO_ENVIRONMENT);
getOption(RuntimeOptions.DISABLE_IR_CACHES_KEY) || isParallelismEnabled;
this.rootIOPermissions = getOption(EnsoLanguage.IO_ENVIRONMENT);
this.shouldWaitForPendingSerializationJobs =
environment.getOptions().get(RuntimeOptions.WAIT_FOR_PENDING_SERIALIZATION_JOBS_KEY);
getOption(RuntimeOptions.WAIT_FOR_PENDING_SERIALIZATION_JOBS_KEY);
this.compilerConfig =
new CompilerConfig(
isParallelismEnabled,
true,
environment.getOptions().get(RuntimeOptions.STRICT_ERRORS_KEY),
getOption(RuntimeOptions.STRICT_ERRORS_KEY),
scala.Option.empty());
this.home = home;
this.builtins = new Builtins(this);
@ -408,7 +415,7 @@ public class EnsoContext {
* @return true if the strict errors option is enabled, false otherwise.
*/
public boolean isStrictErrors() {
return getEnvironment().getOptions().get(RuntimeOptions.STRICT_ERRORS_KEY);
return getOption(RuntimeOptions.STRICT_ERRORS_KEY);
}
/**
@ -417,7 +424,7 @@ public class EnsoContext {
* @return true if project-level suggestion indexing is enabled.
*/
public boolean isProjectSuggestionsEnabled() {
return getEnvironment().getOptions().get(RuntimeOptions.ENABLE_PROJECT_SUGGESTIONS_KEY);
return getOption(RuntimeOptions.ENABLE_PROJECT_SUGGESTIONS_KEY);
}
/**
@ -426,7 +433,13 @@ public class EnsoContext {
* @return true if the suggestions indexing is enabled for external libraries.
*/
public boolean isGlobalSuggestionsEnabled() {
return getEnvironment().getOptions().get(RuntimeOptions.ENABLE_GLOBAL_SUGGESTIONS_KEY);
return getOption(RuntimeOptions.ENABLE_GLOBAL_SUGGESTIONS_KEY);
}
/** The job parallelism or 1 */
public int getJobParallelism() {
var n = getOption(RuntimeServerInfo.JOB_PARALLELISM_KEY);
return n == null ? 1 : n.intValue();
}
/** Creates a new thread that has access to the current language context. */
@ -508,4 +521,20 @@ public class EnsoContext {
public int getMaxUnboxingLayouts() {
return 10;
}
private <T> T getOption(OptionKey<T> key) {
var options = getEnvironment().getOptions();
var safely = false;
assert safely = true;
if (safely) {
for (var d : options.getDescriptors()) {
if (d.getKey() == key) {
return options.get(key);
}
}
return null;
} else {
return options.get(key);
}
}
}

16
engine/runtime/src/main/java/org/enso/interpreter/runtime/Module.java
View File

@ -364,16 +364,22 @@ public final class Module implements TruffleObject {
* @return
*/
public final SourceSection createSection(int sourceStartIndex, int sourceLength) {
final Source src = sources.source();
var src = sources.source();
if (src == null) {
return null;
}
allSources.put(src, this);
int startDelta = patchedValues == null ? 0 : patchedValues.findDelta(sourceStartIndex, false);
int endDelta =
var startDelta = patchedValues == null ? 0 : patchedValues.findDelta(sourceStartIndex, false);
var endDelta =
patchedValues == null ? 0 : patchedValues.findDelta(sourceStartIndex + sourceLength, true);
final int start = sourceStartIndex + startDelta;
final int length = sourceLength + endDelta - startDelta;
var start = sourceStartIndex + startDelta;
var length = sourceLength + endDelta - startDelta;
if (start + length == src.getLength() + 1) {
length--;
}
if (start + length > src.getLength()) {
return null;
}
return src.createSection(start, length);
}

28
engine/runtime/src/main/java/org/enso/interpreter/runtime/callable/atom/Atom.java
View File

@ -1,15 +1,7 @@
package org.enso.interpreter.runtime.callable.atom;
import com.oracle.truffle.api.Assumption;
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.Truffle;
import com.oracle.truffle.api.dsl.Cached.Shared;
import com.oracle.truffle.api.dsl.Fallback;
import com.oracle.truffle.api.profiles.ConditionProfile;
import com.oracle.truffle.api.profiles.ValueProfile;
import com.oracle.truffle.api.utilities.TriState;
import com.oracle.truffle.api.dsl.Cached;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.exception.AbstractTruffleException;
@ -19,22 +11,16 @@ import com.oracle.truffle.api.library.ExportLibrary;
import com.oracle.truffle.api.library.ExportMessage;
import com.oracle.truffle.api.nodes.ExplodeLoop;
import com.oracle.truffle.api.profiles.BranchProfile;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.enso.interpreter.runtime.callable.UnresolvedSymbol;
import org.enso.interpreter.runtime.callable.function.Function;
import org.enso.interpreter.runtime.data.Array;
import org.enso.interpreter.runtime.data.Type;
import org.enso.interpreter.runtime.data.text.Text;
import org.enso.interpreter.runtime.error.PanicException;
import org.enso.interpreter.runtime.library.dispatch.TypesLibrary;
import org.enso.interpreter.runtime.type.TypesGen;
import java.util.Map;
import org.enso.interpreter.EnsoLanguage;
import org.enso.interpreter.runtime.error.WarningsLibrary;
import java.util.Map;
/**
* A runtime representation of an Atom in Enso.
@ -249,6 +235,16 @@ public abstract class Atom implements TruffleObject {
return Text.create(msg);
}
@ExportMessage
Class<EnsoLanguage> getLanguage() {
return EnsoLanguage.class;
}
@ExportMessage
boolean hasLanguage() {
return true;
}
@ExportMessage
boolean hasType() {
return true;

14
engine/runtime/src/main/java/org/enso/interpreter/runtime/callable/atom/AtomConstructor.java
View File

@ -10,7 +10,7 @@ import com.oracle.truffle.api.library.CachedLibrary;
import com.oracle.truffle.api.library.ExportLibrary;
import com.oracle.truffle.api.library.ExportMessage;
import com.oracle.truffle.api.nodes.RootNode;
import com.oracle.truffle.api.utilities.TriState;
import org.enso.interpreter.EnsoLanguage;
import org.enso.interpreter.node.ClosureRootNode;
import org.enso.interpreter.node.ExpressionNode;
import org.enso.interpreter.node.callable.argument.ReadArgumentNode;
@ -91,13 +91,13 @@ public final class AtomConstructor implements TruffleObject {
*
* @return {@code this}, for convenience
*/
public AtomConstructor initializeFields(ArgumentDefinition... args) {
public AtomConstructor initializeFields(EnsoLanguage language, ArgumentDefinition... args) {
ExpressionNode[] reads = new ExpressionNode[args.length];
for (int i = 0; i < args.length; i++) {
reads[i] = ReadArgumentNode.build(i, null);
}
return initializeFields(
LocalScope.root(), new ExpressionNode[0], reads, new Annotation[0], args);
language, LocalScope.root(), new ExpressionNode[0], reads, new Annotation[0], args);
}
/**
@ -110,13 +110,13 @@ public final class AtomConstructor implements TruffleObject {
* @return {@code this}, for convenience
*/
public AtomConstructor initializeFields(
EnsoLanguage language,
LocalScope localScope,
ExpressionNode[] assignments,
ExpressionNode[] varReads,
Annotation[] annotations,
ArgumentDefinition... args) {
CompilerDirectives.transferToInterpreterAndInvalidate();
if (args.length == 0) {
cachedInstance = new BoxingAtom(this);
} else {
@ -126,7 +126,7 @@ public final class AtomConstructor implements TruffleObject {
boxedLayout = Layout.create(args.length, 0);
}
this.constructorFunction =
buildConstructorFunction(localScope, assignments, varReads, annotations, args);
buildConstructorFunction(language, localScope, assignments, varReads, annotations, args);
generateQualifiedAccessor();
return this;
}
@ -145,17 +145,17 @@ public final class AtomConstructor implements TruffleObject {
* {@link AtomConstructor}
*/
private Function buildConstructorFunction(
EnsoLanguage language,
LocalScope localScope,
ExpressionNode[] assignments,
ExpressionNode[] varReads,
Annotation[] annotations,
ArgumentDefinition[] args) {
ExpressionNode instantiateNode = InstantiateNode.build(this, varReads);
BlockNode instantiateBlock = BlockNode.buildSilent(assignments, instantiateNode);
RootNode rootNode =
ClosureRootNode.build(
null,
language,
localScope,
definitionScope,
instantiateBlock,

46
engine/runtime/src/main/java/org/enso/interpreter/runtime/data/Type.java
View File

@ -5,9 +5,11 @@ import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.interop.InteropLibrary;
import com.oracle.truffle.api.interop.TruffleObject;
import com.oracle.truffle.api.interop.UnknownIdentifierException;
import com.oracle.truffle.api.interop.UnsupportedMessageException;
import com.oracle.truffle.api.library.CachedLibrary;
import com.oracle.truffle.api.library.ExportLibrary;
import com.oracle.truffle.api.library.ExportMessage;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.nodes.RootNode;
import org.enso.interpreter.Constants;
import org.enso.interpreter.EnsoLanguage;
@ -182,17 +184,27 @@ public final class Type implements TruffleObject {
}
@ExportMessage
boolean hasMetaObject() {
boolean hasMetaObject(@CachedLibrary("this") InteropLibrary lib) {
if (isNothing(lib)) {
return false;
}
return true;
}
@ExportMessage
Type getMetaObject() {
Type getMetaObject(@CachedLibrary("this") InteropLibrary lib) throws UnsupportedMessageException {
if (isNothing(lib)) {
throw UnsupportedMessageException.create();
}
return getType();
}
@ExportMessage
Object getMetaParents() {
Object getMetaParents(@CachedLibrary("this") InteropLibrary lib)
throws UnsupportedMessageException {
if (isNothing(lib)) {
throw UnsupportedMessageException.create();
}
assert supertype != null;
return new Array(supertype);
}
@ -208,16 +220,23 @@ public final class Type implements TruffleObject {
}
@ExportMessage
boolean isMetaObject() {
boolean isMetaObject(@CachedLibrary("this") InteropLibrary lib) {
if (isNothing(lib)) {
return false;
}
return true;
}
@ExportMessage
boolean isMetaInstance(Object instance, @CachedLibrary(limit = "3") TypesLibrary lib) {
boolean isMetaInstance(Object instance, @CachedLibrary(limit = "3") TypesLibrary lib)
throws UnsupportedMessageException {
var b = EnsoContext.get(lib).getBuiltins();
if (b.any() == this) {
return true;
}
if (isNothing(lib)) {
throw UnsupportedMessageException.create();
}
var type = lib.getType(instance);
while (type != null && type != b.any()) {
if (type == this) {
@ -229,12 +248,20 @@ public final class Type implements TruffleObject {
}
@ExportMessage
String getMetaSimpleName() {
String getMetaSimpleName(@CachedLibrary("this") InteropLibrary lib)
throws UnsupportedMessageException {
if (isNothing(lib)) {
throw UnsupportedMessageException.create();
}
return getName();
}
@ExportMessage
String getMetaQualifiedName() {
String getMetaQualifiedName(@CachedLibrary("this") InteropLibrary lib)
throws UnsupportedMessageException {
if (isNothing(lib)) {
throw UnsupportedMessageException.create();
}
return getQualifiedName().toString();
}
@ -287,4 +314,9 @@ public final class Type implements TruffleObject {
public Map<String, AtomConstructor> getConstructors() {
return constructors;
}
private boolean isNothing(Node lib) {
var b = EnsoContext.get(lib).getBuiltins();
return this == b.nothing();
}
}

37
engine/runtime/src/main/java/org/enso/interpreter/runtime/error/PanicException.java
View File

@ -9,12 +9,19 @@ import com.oracle.truffle.api.library.ExportLibrary;
import com.oracle.truffle.api.library.ExportMessage;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.source.SourceSection;
import org.enso.interpreter.node.BaseNode.TailStatus;
import org.enso.interpreter.node.callable.IndirectInvokeMethodNode;
import org.enso.interpreter.node.callable.InvokeCallableNode.ArgumentsExecutionMode;
import org.enso.interpreter.node.callable.InvokeCallableNode.DefaultsExecutionMode;
import org.enso.interpreter.node.expression.builtin.text.util.TypeToDisplayTextNode;
import org.enso.interpreter.node.expression.builtin.text.util.TypeToDisplayTextNodeGen;
import org.enso.interpreter.runtime.EnsoContext;
import org.enso.interpreter.runtime.callable.UnresolvedSymbol;
import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo;
import org.enso.interpreter.runtime.data.Type;
import org.enso.interpreter.runtime.data.text.Text;
import org.enso.interpreter.runtime.library.dispatch.TypesLibrary;
import org.enso.interpreter.runtime.state.State;
/** An exception type for user thrown panic exceptions. */
@ExportLibrary(value = InteropLibrary.class, delegateTo = "payload")
@ -76,17 +83,35 @@ public class PanicException extends AbstractTruffleException {
return true;
}
static UnresolvedSymbol toDisplayText(IndirectInvokeMethodNode payloads) {
var ctx = EnsoContext.get(payloads);
var scope = ctx.getBuiltins().panic().getDefinitionScope();
return UnresolvedSymbol.build("to_display_text", scope);
}
@ExportMessage
Object getExceptionMessage(
@CachedLibrary(limit = "5") InteropLibrary payloads,
@Cached IndirectInvokeMethodNode payloads,
@Cached(value = "toDisplayText(payloads)", allowUncached = true)
UnresolvedSymbol toDisplayText,
@CachedLibrary(limit = "3") InteropLibrary strings,
@Cached TypeToDisplayTextNode typeToDisplayTextNode) {
var ctx = EnsoContext.get(payloads);
var text =
payloads.execute(
null,
State.create(ctx),
toDisplayText,
payload,
new Object[] {payload},
new CallArgumentInfo[] {new CallArgumentInfo("self")},
DefaultsExecutionMode.EXECUTE,
ArgumentsExecutionMode.EXECUTE,
TailStatus.NOT_TAIL,
0);
try {
return Text.create(strings.asString(payloads.invokeMember(payload, "to_display_text")));
} catch (UnsupportedTypeException
| UnsupportedMessageException
| ArityException
| UnknownIdentifierException e) {
return Text.create(strings.asString(text));
} catch (UnsupportedMessageException e) {
return Text.create(typeToDisplayTextNode.execute(payload));
}
}

1
engine/runtime/src/main/java/org/enso/interpreter/runtime/scope/TopLevelScope.java
View File

@ -206,6 +206,7 @@ public final class TopLevelScope implements TruffleObject {
|| member.equals(MethodNames.TopScope.CREATE_MODULE)
|| member.equals(MethodNames.TopScope.REGISTER_MODULE)
|| member.equals(MethodNames.TopScope.UNREGISTER_MODULE)
|| member.equals(MethodNames.TopScope.LEAK_CONTEXT)
|| member.equals(MethodNames.TopScope.COMPILE);
}

1
engine/runtime/src/main/scala/org/enso/compiler/codegen/IrToTruffle.scala
View File

@ -292,6 +292,7 @@ class IrToTruffle(
}
if (!atomCons.isInitialized) {
atomCons.initializeFields(
language,
localScope,
assignments.toArray,
reads.toArray,

6
engine/runtime/src/main/scala/org/enso/interpreter/instrument/execution/JobExecutionEngine.scala
View File

@ -2,7 +2,6 @@ package org.enso.interpreter.instrument.execution
import org.enso.interpreter.instrument.InterpreterContext
import org.enso.interpreter.instrument.job.{Job, UniqueJob}
import org.enso.polyglot.RuntimeServerInfo
import org.enso.text.Sha3_224VersionCalculator
import java.util.UUID
@ -36,10 +35,7 @@ final class JobExecutionEngine(
private val context = interpreterContext.executionService.getContext
private val jobParallelism =
interpreterContext.executionService.getContext.getEnvironment.getOptions
.get(RuntimeServerInfo.JOB_PARALLELISM_KEY)
.intValue()
private val jobParallelism = context.getJobParallelism
val jobExecutor: ExecutorService =
Executors.newFixedThreadPool(

26
engine/runtime/src/test/java/org/enso/interpreter/test/BigNumberTest.java
View File

@ -66,11 +66,23 @@ public class BigNumberTest {
if (e.fitsInDouble()) {
doubles++;
}
var n = e.as(Number.class);
assertNotNull("All numbers can be seend as java.lang.Number", n);
var b = new BigInteger(n.toString());
boolean assertsOn = false;
// Explanation at
// https://github.com/enso-org/enso/pull/4074#discussion_r1086222800
// rewrite when proper support for BigInteger is available
// https://github.com/oracle/graal/pull/5490
assert assertsOn = true;
String s;
if (!assertsOn) {
var n = e.as(Number.class);
assertNotNull("All numbers can be seen as java.lang.Number", n);
s = n.toString();
} else {
s = e.toString();
}
var b = new BigInteger(s);
assertNotNull("Each Enso number can be parsed as big integer", b);
assertEquals("Textual values are the same", n.toString(), b.toString());
assertEquals("Textual values are the same", s, b.toString());
values.add(b);
}
assertEquals("There are few long values and rest of doubles", 63, longs);
@ -97,6 +109,12 @@ public class BigNumberTest {
@Test
public void averageOfMixedArrayOverDouble() throws Exception {
boolean assertsOn = false;
assert assertsOn = true;
if (assertsOn) {
// skip this test when asserts are on
return;
}
var code = """
from Standard.Base.Data.Vector import Vector
polyglot java import org.enso.example.TestClass

6
engine/runtime/src/test/java/org/enso/interpreter/test/DebuggingEnsoTest.java
View File

@ -22,7 +22,6 @@ import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@ -40,7 +39,6 @@ import org.graalvm.polyglot.Value;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
public class DebuggingEnsoTest {
@ -406,7 +404,9 @@ public class DebuggingEnsoTest {
Value fooFunc = module.invokeMember(Module.EVAL_EXPRESSION, methodName);
List<Integer> lineNumbers = new ArrayList<>();
try (DebuggerSession session = debugger.startSession((SuspendedEvent event) -> {
steps.remove().onSuspend(event);
if (!steps.isEmpty()) {
steps.remove().onSuspend(event);
}
lineNumbers.add(
event.getSourceSection().getStartLine()
);

3
engine/runtime/src/test/java/org/enso/interpreter/test/EqualsTest.java
View File

@ -20,6 +20,7 @@ import org.junit.runner.RunWith;
public class EqualsTest extends TestBase {
private static Context context;
private EqualsAnyNode equalsNode;
private TestRootNode testRootNode;
@BeforeClass
public static void initContextAndData() {
@ -32,7 +33,9 @@ public class EqualsTest extends TestBase {
executeInContext(
context,
() -> {
testRootNode = new TestRootNode();
equalsNode = EqualsAnyNode.build();
testRootNode.insertChildren(equalsNode);
return null;
});
}

3
engine/runtime/src/test/java/org/enso/interpreter/test/HashCodeTest.java
View File

@ -26,6 +26,7 @@ public class HashCodeTest extends TestBase {
private HashCodeAnyNode hashCodeNode;
private EqualsAnyNode equalsNode;
private TestRootNode testRootNode;
@BeforeClass
public static void initContextAndData() {
@ -39,6 +40,8 @@ public class HashCodeTest extends TestBase {
executeInContext(context, () -> {
hashCodeNode = HashCodeAnyNode.build();
equalsNode = EqualsAnyNode.build();
testRootNode = new TestRootNode();
testRootNode.insertChildren(hashCodeNode, equalsNode);
return null;
});
}

7
engine/runtime/src/test/java/org/enso/interpreter/test/MetaObjectTest.java
View File

@ -84,6 +84,10 @@ public class MetaObjectTest extends TestBase {
var f = new StringWriter();
var err = new PrintWriter(f);
for (var t : g.allTypes()) {
if (t.isNull()) {
expecting.remove("Standard.Base.Nothing.Nothing");
continue;
}
try {
var n = t.getMetaQualifiedName();
assertNotNull("Type " + t + " has meta name", n);
@ -138,6 +142,9 @@ public class MetaObjectTest extends TestBase {
var g = ValuesGenerator.create(ctx);
var expecting = new LinkedHashSet<Value>();
for (var t : g.allTypes()) {
if (t.isNull()) {
continue;
}
switch (t.getMetaSimpleName()) {
// represented as primitive values without meta object
case "Decimal" -> {}

27
engine/runtime/src/test/java/org/enso/interpreter/test/TestBase.java
View File

@ -2,14 +2,18 @@ package org.enso.interpreter.test;
import static org.junit.Assert.assertNotNull;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.interop.InteropLibrary;
import com.oracle.truffle.api.interop.TruffleObject;
import com.oracle.truffle.api.library.ExportLibrary;
import com.oracle.truffle.api.library.ExportMessage;
import com.oracle.truffle.api.nodes.Node;
import com.oracle.truffle.api.nodes.RootNode;
import java.io.ByteArrayOutputStream;
import java.nio.file.Paths;
import java.util.Map;
import java.util.concurrent.Callable;
import org.enso.interpreter.EnsoLanguage;
import org.enso.polyglot.RuntimeOptions;
import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Language;
@ -73,6 +77,29 @@ public abstract class TestBase {
return unwrapper.args[0];
}
/**
* An artificial RootNode. Used for tests of nodes that need to be adopted. Just create this root
* node inside a context, all the other nodes, and insert them via {@link
* #insertChildren(Node...)}.
*/
static class TestRootNode extends RootNode {
TestRootNode() {
super(EnsoLanguage.get(null));
}
void insertChildren(Node... children) {
for (Node child : children) {
insert(child);
}
}
/** In the tests, do not execute this root node, but execute directly the child nodes. */
@Override
public Object execute(VirtualFrame frame) {
throw new AssertionError("should not reach here");
}
}
@ExportLibrary(InteropLibrary.class)
static final class Unwrapper implements TruffleObject {
Object[] args;

3
engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/SystemProcessTest.scala
View File

@ -55,7 +55,8 @@ class SystemProcessTest extends InterpreterTest with OsSpec {
|""".stripMargin
val error = the[InterpreterException] thrownBy eval(code)
error.getMessage should include("java.io.IOException")
error.getMessage should not include "java.io.IOException"
error.getMessage should include("nonexistentcommandxyz")
consumeOut shouldEqual List()
consumeErr shouldEqual List()
}

7
test/Tests/src/Semantic/Meta_Spec.enso
View File

@ -209,6 +209,13 @@ spec =
Meta.get_annotation value "Value" "bar" . should_equal Nothing
Meta.get_annotation value "Value" "baz" . should_equal (My_Type.Value 1 2 3)
Test.group "Check Nothing" <|
Test.specify "Nothing.is_a Nothing" <|
Nothing.is_a Nothing . should_be_true
Test.specify "type_of Nothing is Nothing" <|
Meta.type_of Nothing . should_equal Nothing
Test.group "Atom with holes" <|
Test.specify "construct and fill" <|
pair = Meta.atom_with_hole (e -> My_Type.Value 1 e 3)