enso-org/enso
1
1
Fork 0
mirror of https://github.com/enso-org/enso.git synced 2024-12-23 14:52:01 +03:00
Code Issues Projects Releases Wiki Activity

Import/export syntax error have more specific messages (#6808)

Browse Source
This commit is contained in:
Pavel Marek 2023-05-23 21:10:18 +02:00 committed by GitHub
parent 1ddd36308e
commit fe0a06dcb5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 68 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
engine/runtime/src/main/java/org/enso/compiler/TreeToIr.java
View File

@ -21,7 +21,8 @@ import org.enso.compiler.core.IR$Error$Syntax$UnexpectedDeclarationInType$;
import org.enso.compiler.core.IR$Error$Syntax$UnexpectedExpression$;
import org.enso.compiler.core.IR$Error$Syntax$InvalidEscapeSequence$;
import org.enso.compiler.core.IR$Error$Syntax$EmptyParentheses$;
import org.enso.compiler.core.IR$Error$Syntax$InvalidImport$;
import org.enso.compiler.core.IR$Error$Syntax$InvalidImport;
import org.enso.compiler.core.IR$Error$Syntax$InvalidExport;
import org.enso.compiler.core.IR$Error$Syntax$Reason;
import org.enso.compiler.core.IR$Error$Syntax$UnrecognizedToken$;
import org.enso.compiler.core.IR$Error$Syntax$UnsupportedSyntax;
@ -70,6 +71,7 @@ import org.enso.syntax2.TextElement;
import org.enso.syntax2.Token;
import org.enso.syntax2.Tree;
import org.enso.syntax2.Tree.Invalid;
import scala.Option;
import scala.collection.immutable.LinearSeq;
import scala.collection.immutable.List;
@ -1525,10 +1527,24 @@ final class TreeToIr {
meta(), diag()
);
} catch (SyntaxException err) {
return err.toError(IR$Error$Syntax$InvalidImport$.MODULE$);
if (err.where instanceof Invalid invalid) {
return err.toError(invalidImportReason(invalid.getError()));
} else {
return err.toError(invalidImportReason(null));
}
}
}
private IR$Error$Syntax$Reason invalidImportReason(String msg) {
return new IR$Error$Syntax$InvalidImport(
Objects.requireNonNullElse(msg, "Imports must have a valid module path"));
}
private IR$Error$Syntax$Reason invalidExportReason(String msg) {
return new IR$Error$Syntax$InvalidExport(
Objects.requireNonNullElse(msg, "Exports must have a valid module path"));
}
@SuppressWarnings("unchecked")
private String extractPackageAndName(List<IR.Name> qualifiedName, StringBuilder pkg) {
String cls = null;
@ -1583,7 +1599,11 @@ final class TreeToIr {
meta(), diag()
);
} catch (SyntaxException err) {
return err.toError(IR$Error$Syntax$InvalidImport$.MODULE$);
if (err.where instanceof Invalid invalid) {
return err.toError(invalidExportReason(invalid.getError()));
} else {
return err.toError(invalidExportReason(null));
}
}
}

13
engine/runtime/src/main/scala/org/enso/compiler/core/IR.scala
View File

@ -7803,9 +7803,18 @@ object IR {
s"Cannot define a pattern outside a pattern context"
}
case object InvalidImport extends Reason {
case class InvalidImport(
message: String = "Imports must have a valid module path"
) extends Reason {
override def explanation: String =
s"Imports must have a valid module path"
s"Invalid Import: $message"
}
case class InvalidExport(
message: String = "Exports must have a valid module path"
) extends Reason {
override def explanation: String =
s"Invalid Export: $message"
}
case object InvalidStandaloneSignature extends Reason {

55
engine/runtime/src/test/java/org/enso/compiler/ErrorCompilerTest.java
View File

@ -1,10 +1,12 @@
package org.enso.compiler;
import java.util.Objects;
import org.enso.compiler.core.IR;
import org.enso.compiler.core.IR$Error$Syntax;
import org.enso.compiler.core.IR$Error$Syntax$InvalidEscapeSequence$;
import org.enso.compiler.core.IR$Error$Syntax$Reason;
import org.enso.compiler.core.IR$Error$Syntax$InvalidImport$;
import org.enso.compiler.core.IR$Error$Syntax$InvalidImport;
import org.enso.compiler.core.IR$Error$Syntax$InvalidExport;
import org.enso.compiler.core.IR$Error$Syntax$UnexpectedExpression$;
import org.enso.compiler.core.IR$Error$Syntax$UnrecognizedToken$;
import org.enso.compiler.core.IR$Error$Syntax$UnsupportedSyntax;
@ -144,40 +146,49 @@ public class ErrorCompilerTest extends CompilerTest {
assertSingleSyntaxError(ir, IR$Error$Syntax$UnexpectedExpression$.MODULE$, "Unexpected expression", 0, 13);
}
private IR$Error$Syntax$InvalidImport invalidImport(String msg) {
return new IR$Error$Syntax$InvalidImport(msg);
}
private IR$Error$Syntax$InvalidExport invalidExport(String msg) {
return new IR$Error$Syntax$InvalidExport(msg);
}
@Test
public void malformedImport3() throws Exception {
var ir = parse("import Foo as Foo, Bar");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 14, 22);
assertSingleSyntaxError(ir, invalidImport("Expected identifier."), null, 14, 22);
}
@Test
public void malformedImport4() throws Exception {
var ir = parse("import Foo as Foo.Bar");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 14, 21);
assertSingleSyntaxError(ir, invalidImport("Expected identifier."), null, 14, 21);
}
@Test
public void malformedImport5() throws Exception {
var ir = parse("import Foo as");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 13, 13);
assertSingleSyntaxError(ir, invalidImport("Expected tokens."), null, 13, 13);
}
@Test
public void malformedImport6() throws Exception {
var ir = parse("import Foo as Bar.Baz");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 14, 21);
assertSingleSyntaxError(ir, invalidImport("Expected identifier."), null, 14, 21);
}
@Test
public void malformedImport7() throws Exception {
var ir = parse("import Foo hiding");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 7, 17);
assertSingleSyntaxError(ir, invalidImport("Expected qualified name."), null, 7, 17);
}
@Test
public void malformedImport8() throws Exception {
var ir = parse("import Foo hiding X,");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 7, 20);
assertSingleSyntaxError(ir, invalidImport("Malformed comma-delimited sequence."), null, 7, 20);
}
@Test
@ -203,25 +214,25 @@ public class ErrorCompilerTest extends CompilerTest {
@Test
public void malformedImport11() throws Exception {
var ir = parse("from import all");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 4, 4);
assertSingleSyntaxError(ir, invalidImport("Expected tokens."), null, 4, 4);
}
@Test
public void malformedImport12() throws Exception {
var ir = parse("from Foo import all hiding");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 26, 26);
assertSingleSyntaxError(ir, invalidImport("Expected tokens."), null, 26, 26);
}
@Test
public void malformedImport13() throws Exception {
var ir = parse("from Foo import all hiding X.Y");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 27, 30);
assertSingleSyntaxError(ir, invalidImport("Expected identifier."), null, 27, 30);
}
@Test
public void malformedImport14() throws Exception {
var ir = parse("from Foo import Some.Nested.Module.Path");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 16, 39);
assertSingleSyntaxError(ir, invalidImport("Expected identifier."), null, 16, 39);
}
@Test
@ -239,55 +250,55 @@ public class ErrorCompilerTest extends CompilerTest {
@Test
public void malformedExport3() throws Exception {
var ir = parse("export Foo as Foo, Bar");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 14, 22);
assertSingleSyntaxError(ir, invalidExport("Expected identifier."), null, 14, 22);
}
@Test
public void malformedExport4() throws Exception {
var ir = parse("export Foo as Foo.Bar");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 14, 21);
assertSingleSyntaxError(ir, invalidExport("Expected identifier."), null, 14, 21);
}
@Test
public void malformedExport5() throws Exception {
var ir = parse("export Foo as");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 13, 13);
assertSingleSyntaxError(ir, invalidExport("Expected tokens."), null, 13, 13);
}
@Test
public void malformedExport6() throws Exception {
var ir = parse("export Foo as Bar.Baz");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 14, 21);
assertSingleSyntaxError(ir, invalidExport("Expected identifier."), null, 14, 21);
}
@Test
public void malformedExport7() throws Exception {
var ir = parse("export Foo hiding");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 7, 17);
assertSingleSyntaxError(ir, invalidExport("Expected qualified name."), null, 7, 17);
}
@Test
public void malformedExport8() throws Exception {
var ir = parse("export Foo hiding X,");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 7, 20);
assertSingleSyntaxError(ir, invalidExport("Malformed comma-delimited sequence."), null, 7, 20);
}
@Test
public void malformedExport9() throws Exception {
var ir = parse("from export all");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 4, 4);
assertSingleSyntaxError(ir, invalidExport("Expected tokens."), null, 4, 4);
}
@Test
public void malformedExport10() throws Exception {
var ir = parse("from Foo export all hiding");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 26, 26);
assertSingleSyntaxError(ir, invalidExport("Expected tokens."), null, 26, 26);
}
@Test
public void malformedExport11() throws Exception {
var ir = parse("from Foo export all hiding X.Y");
assertSingleSyntaxError(ir, IR$Error$Syntax$InvalidImport$.MODULE$, "Imports must have a valid module path", 27, 30);
assertSingleSyntaxError(ir, invalidExport("Expected identifier."), null, 27, 30);
}
@Test
@ -367,7 +378,9 @@ public class ErrorCompilerTest extends CompilerTest {
) {
var errors = assertIR(ir, IR$Error$Syntax.class, 1);
assertEquals(type, errors.head().reason());
assertEquals(msg, errors.head().message());
if (msg != null) {
assertEquals(msg, errors.head().message());
}
assertEquals(new Location(start, end), errors.head().location().get().location());
}