From 623998186961e7a47b548c1fa12b2f2585cfb193 Mon Sep 17 00:00:00 2001 From: Islon Scherer Date: Mon, 29 Jun 2026 18:06:34 +0200 Subject: [PATCH] Improve error message for aliased references (#1695) --- .../java/org/pkl/core/ast/type/TypeNode.java | 119 +++++++++++++++--- .../pkl/core/runtime/StackTraceGenerator.java | 4 + .../org/pkl/core/runtime/VmBugException.java | 6 +- .../org/pkl/core/runtime/VmEvalException.java | 6 +- .../org/pkl/core/runtime/VmException.java | 13 +- .../pkl/core/runtime/VmExceptionBuilder.java | 20 ++- .../runtime/VmStackOverflowException.java | 3 +- .../org/pkl/core/runtime/VmTypeAlias.java | 11 +- .../runtime/VmUndefinedValueException.java | 6 +- .../core/runtime/VmWrappedEvalException.java | 4 +- .../input/errors/reference21.pkl | 7 ++ .../input/errors/reference22.pkl | 6 + .../input/errors/reference23.pkl | 7 ++ .../output/errors/reference10.err | 4 + .../output/errors/reference11.err | 12 ++ .../output/errors/reference12.err | 4 + .../output/errors/reference21.err | 14 +++ .../output/errors/reference22.err | 14 +++ .../output/errors/reference23.err | 10 ++ .../output/errors/reference8.err | 4 + .../output/errors/reference9.err | 4 + 21 files changed, 240 insertions(+), 38 deletions(-) create mode 100644 pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference21.pkl create mode 100644 pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference22.pkl create mode 100644 pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference23.pkl create mode 100644 pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference21.err create mode 100644 pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference22.err create mode 100644 pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference23.err diff --git a/pkl-core/src/main/java/org/pkl/core/ast/type/TypeNode.java b/pkl-core/src/main/java/org/pkl/core/ast/type/TypeNode.java index c823074bd..455f5bf68 100644 --- a/pkl-core/src/main/java/org/pkl/core/ast/type/TypeNode.java +++ b/pkl-core/src/main/java/org/pkl/core/ast/type/TypeNode.java @@ -27,7 +27,10 @@ import com.oracle.truffle.api.frame.FrameSlotKind; import com.oracle.truffle.api.frame.VirtualFrame; import com.oracle.truffle.api.nodes.ExplodeLoop; import com.oracle.truffle.api.nodes.LoopNode; +import com.oracle.truffle.api.nodes.Node; +import com.oracle.truffle.api.nodes.NodeUtil; import com.oracle.truffle.api.source.SourceSection; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Map; @@ -38,6 +41,7 @@ import org.jspecify.annotations.Nullable; import org.pkl.core.PType; import org.pkl.core.PType.StringLiteral; import org.pkl.core.PklBugException; +import org.pkl.core.StackFrame; import org.pkl.core.TypeParameter; import org.pkl.core.ast.*; import org.pkl.core.ast.builder.SymbolTable.CustomThisScope; @@ -54,6 +58,7 @@ import org.pkl.core.util.EconomicMaps; import org.pkl.core.util.EconomicSets; import org.pkl.core.util.LateInit; import org.pkl.core.util.MutableBoolean; +import org.pkl.core.util.MutableReference; public abstract class TypeNode extends PklNode { @@ -2138,7 +2143,17 @@ public abstract class TypeNode extends PklNode { this.domainTypeNode = domainTypeNode; this.referentTypeNode = referentTypeNode; this.getModuleNode = new GetModuleNode(sourceSection); - validateTypeArguments(sourceSection); + // A type constraint anywhere in the referent is forbidden, including one reached through a + // type alias used in the referent. + var constraint = findReferentConstraint(); + if (constraint != null) { + CompilerDirectives.transferToInterpreter(); + throw exceptionBuilder() + .evalError("invalidReferenceTypeAnnotationWithConstraint") + .withLeadingStackFrames( + buildReferentConstraintFrames(constraint, getSourceSection(), null)) + .build(); + } } @Specialization @@ -2173,26 +2188,69 @@ public abstract class TypeNode extends PklNode { sourceSection, value, TypeNode.export(domainTypeNode), referentType); } - public void validateTypeArguments(@Nullable SourceSection aliasSourceSection) { - // constraints may not be used in Reference type annotation referents - // walk the type and throw if any part of the referent is constrained - - // TODO improve error message when this type node and/or referent constraint are behind type - // aliases + /** + * Type constraints may not appear anywhere in a {@code Reference}'s referent type argument. + * Walks the referent type and returns the first offending {@link ConstrainedTypeNode} , or + * {@code null} if the referent is constraint-free. + */ + public @Nullable ConstrainedTypeNode findReferentConstraint() { + var found = new MutableReference<@Nullable ConstrainedTypeNode>(null); referentTypeNode.acceptTypeNode( true, (typeNode) -> { - if (typeNode instanceof ConstrainedTypeNode) { - CompilerDirectives.transferToInterpreter(); - var err = - exceptionBuilder().evalError("invalidReferenceTypeAnnotationWithConstraint"); - if (aliasSourceSection != null) { - err.withSourceSection(aliasSourceSection); - } - throw err.build(); + if (typeNode instanceof ConstrainedTypeNode constrainedTypeNode) { + found.set(constrainedTypeNode); + return false; } return true; }); + return found.getOrNull(); + } + + /** Builds the frames to show ahead of an "invalid referent constraint" error. */ + public static List buildReferentConstraintFrames( + ConstrainedTypeNode constraintNode, + SourceSection usageSection, + @Nullable VmTypeAlias outermostAlias) { + var frames = new ArrayList(); + for (Node node = constraintNode; node != null; node = node.getParent()) { + if (!(node instanceof ConstrainedTypeNode + || node instanceof TypeAliasTypeNode + || node instanceof ReferenceTypeNode)) { + continue; + } + var section = node.getSourceSection(); + //noinspection ConstantValue + if (section == null || !section.isAvailable() || isWithin(usageSection, section)) { + continue; + } + var owner = ownerAlias(node, outermostAlias); + if (owner != null) { + frames.add(VmUtils.createStackFrame(section, owner.getQualifiedName())); + } + } + return frames; + } + + /** + * The type alias whose body contains {@code node}: the nearest enclosing alias, else the + * outermost alias being instantiated (which is {@code null} for a directly-used Reference). + */ + @SuppressWarnings("DataFlowIssue") + private static @Nullable VmTypeAlias ownerAlias( + Node node, @Nullable VmTypeAlias outermostAlias) { + var parent = NodeUtil.findParent(node, TypeAliasTypeNode.class); + //noinspection ConstantValue + if (parent != null) { + return parent.typeAlias; + } + return outermostAlias; + } + + private static boolean isWithin(SourceSection outer, SourceSection inner) { + return inner.getSource().equals(outer.getSource()) + && inner.getCharIndex() >= outer.getCharIndex() + && inner.getCharEndIndex() <= outer.getCharEndIndex(); } @Fallback @@ -2703,13 +2761,42 @@ public abstract class TypeNode extends PklNode { this.typeAlias = typeAlias; this.typeArgumentNodes = typeArgumentNodes; - aliasedTypeNode = typeAlias.instantiate(typeArgumentNodes, sourceSection); + aliasedTypeNode = typeAlias.instantiate(typeArgumentNodes); + checkReferentConstraints(typeAlias); + } + + /** + * Reports a forbidden type constraint that a type argument introduced into a {@code + * Reference}'s referent through this (generic) alias. The error is reported at this usage type + * expression, with leading frames for the constraint and every alias layer it passed through. + */ + private void checkReferentConstraints(VmTypeAlias outermostAlias) { + aliasedTypeNode.accept( + node -> { + if (node instanceof ReferenceTypeNode referenceTypeNode) { + var constraint = referenceTypeNode.findReferentConstraint(); + if (constraint != null) { + CompilerDirectives.transferToInterpreter(); + throw exceptionBuilder() + .evalError("invalidReferenceTypeAnnotationWithConstraint") + .withLeadingStackFrames( + ReferenceTypeNode.buildReferentConstraintFrames( + constraint, getSourceSection(), outermostAlias)) + .build(); + } + } + return true; + }); } public TypeNode getAliasedTypeNode() { return aliasedTypeNode; } + public VmTypeAlias getTypeAlias() { + return typeAlias; + } + @Override public FrameSlotKind getFrameSlotKind() { return aliasedTypeNode.getFrameSlotKind(); diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/StackTraceGenerator.java b/pkl-core/src/main/java/org/pkl/core/runtime/StackTraceGenerator.java index ee9fab8dc..6900111dd 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/StackTraceGenerator.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/StackTraceGenerator.java @@ -38,6 +38,10 @@ final class StackTraceGenerator { } private List capture() { + // frames that aren't part of the runtime call stack are + // shown ahead of the captured frames. + frames.addAll(exception.getLeadingStackFrames()); + var truffleElements = TruffleStackTrace.getStackTrace(exception); if (truffleElements.isEmpty()) { addFrame(exception.getSourceSection(), exception.getMemberName()); diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmBugException.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmBugException.java index 4c839477b..2298652fd 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmBugException.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmBugException.java @@ -38,7 +38,8 @@ public final class VmBugException extends VmException { @Nullable SourceSection sourceSection, @Nullable String memberName, @Nullable BiConsumer hintBuilder, - Map insertedStackFrames) { + Map insertedStackFrames, + List leadingStackFrames) { super( message, @@ -51,7 +52,8 @@ public final class VmBugException extends VmException { sourceSection, memberName, hintBuilder, - insertedStackFrames); + insertedStackFrames, + leadingStackFrames); } @Override diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmEvalException.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmEvalException.java index 24a20d01a..0befe6735 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmEvalException.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmEvalException.java @@ -37,7 +37,8 @@ public class VmEvalException extends VmException { @Nullable SourceSection sourceSection, @Nullable String memberName, @Nullable BiConsumer hintBuilder, - Map insertedStackFrames) { + Map insertedStackFrames, + List leadingStackFrames) { super( message, @@ -50,6 +51,7 @@ public class VmEvalException extends VmException { sourceSection, memberName, hintBuilder, - insertedStackFrames); + insertedStackFrames, + leadingStackFrames); } } diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmException.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmException.java index ade09e98d..d518bd327 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmException.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmException.java @@ -34,6 +34,7 @@ public abstract class VmException extends AbstractTruffleException { private final @Nullable SourceSection sourceSection; private final @Nullable String memberName; private final Map insertedStackFrames; + private final List leadingStackFrames; @Nullable private final BiConsumer messageBuilder; @Nullable protected BiConsumer hintBuilder; @@ -48,7 +49,8 @@ public abstract class VmException extends AbstractTruffleException { @Nullable SourceSection sourceSection, @Nullable String memberName, @Nullable BiConsumer hintBuilder, - Map insertedStackFrames) { + Map insertedStackFrames, + List leadingStackFrames) { super(message, cause, UNLIMITED_STACK_TRACE, location); assert message != null || messageBuilder != null; this.messageBuilder = messageBuilder; @@ -58,6 +60,7 @@ public abstract class VmException extends AbstractTruffleException { this.sourceSection = sourceSection; this.memberName = memberName; this.insertedStackFrames = insertedStackFrames; + this.leadingStackFrames = leadingStackFrames; this.hintBuilder = hintBuilder; } @@ -89,6 +92,14 @@ public abstract class VmException extends AbstractTruffleException { return insertedStackFrames; } + /** + * Stack frames to prepend to the rendered stack trace, ahead of the captured frames. Used to show + * source locations that aren't part of the runtime call stack. + */ + public final List getLeadingStackFrames() { + return leadingStackFrames; + } + public @Nullable BiConsumer getMessageBuilder() { return messageBuilder; } diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmExceptionBuilder.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmExceptionBuilder.java index 267db2570..cd0fc298b 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmExceptionBuilder.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmExceptionBuilder.java @@ -99,6 +99,7 @@ public final class VmExceptionBuilder { private @Nullable Node location; private @Nullable SourceSection sourceSection; private @Nullable String memberName; + private List leadingStackFrames = List.of(); public VmExceptionBuilder typeMismatch(Object value, VmClass expectedType) { if (value instanceof VmNull) { @@ -359,6 +360,15 @@ public final class VmExceptionBuilder { return this; } + /** + * Frames to show ahead of the captured stack trace (see {@link + * VmException#getLeadingStackFrames()}). + */ + public VmExceptionBuilder withLeadingStackFrames(List leadingStackFrames) { + this.leadingStackFrames = leadingStackFrames; + return this; + } + public VmException build() { if (message != null && messageBuilder != null) { throw new IllegalStateException("Both message and messageBuilder are set"); @@ -387,7 +397,8 @@ public final class VmExceptionBuilder { sourceSection, memberName, hintBuilder, - effectiveInsertedStackFrames); + effectiveInsertedStackFrames, + leadingStackFrames); case UNDEFINED_VALUE -> new VmUndefinedValueException( message, @@ -401,7 +412,8 @@ public final class VmExceptionBuilder { memberName, hintBuilder, receiver, - effectiveInsertedStackFrames); + effectiveInsertedStackFrames, + leadingStackFrames); case BUG -> new VmBugException( message, @@ -414,7 +426,8 @@ public final class VmExceptionBuilder { sourceSection, memberName, hintBuilder, - effectiveInsertedStackFrames); + effectiveInsertedStackFrames, + leadingStackFrames); case WRAPPED -> { assert wrappedException != null; yield new VmWrappedEvalException( @@ -429,6 +442,7 @@ public final class VmExceptionBuilder { memberName, hintBuilder, effectiveInsertedStackFrames, + leadingStackFrames, wrappedException); } }; diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmStackOverflowException.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmStackOverflowException.java index 29d8859f7..ed9c203cb 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmStackOverflowException.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmStackOverflowException.java @@ -32,6 +32,7 @@ public final class VmStackOverflowException extends VmException { null, null, null, - new HashMap<>()); + new HashMap<>(), + List.of()); } } diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmTypeAlias.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmTypeAlias.java index 26bfb48d5..03480827a 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmTypeAlias.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmTypeAlias.java @@ -32,7 +32,6 @@ import org.pkl.core.TypeParameter; import org.pkl.core.ast.VmModifier; import org.pkl.core.ast.type.TypeNode; import org.pkl.core.ast.type.TypeNode.ConstrainedTypeNode; -import org.pkl.core.ast.type.TypeNode.ReferenceTypeNode; import org.pkl.core.ast.type.TypeNode.TypeVariableNode; import org.pkl.core.ast.type.TypeNode.UnknownTypeNode; import org.pkl.core.util.LateInit; @@ -178,8 +177,7 @@ public final class VmTypeAlias extends VmValue { } @TruffleBoundary - public TypeNode instantiate( - TypeNode[] typeArgumentNodes, SourceSection typeAliasTypeNodeSourceSection) { + public TypeNode instantiate(TypeNode[] typeArgumentNodes) { // Cloning the type node means that the entire type check remains within a single root node, // which should be good for interpreted and compiled performance alike: // * Fewer root nodes to call @@ -201,13 +199,6 @@ public final class VmTypeAlias extends VmValue { } return true; }); - clone.accept( - node -> { - if (node instanceof ReferenceTypeNode referenceTypeNode) { - referenceTypeNode.validateTypeArguments(typeAliasTypeNodeSourceSection); - } - return true; - }); return clone; } diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmUndefinedValueException.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmUndefinedValueException.java index 4a6577750..562fcc6b2 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmUndefinedValueException.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmUndefinedValueException.java @@ -43,7 +43,8 @@ public final class VmUndefinedValueException extends VmEvalException { @Nullable String memberName, @Nullable BiConsumer hintBuilder, @Nullable Object receiver, - @Nullable Map insertedStackFrames) { + @Nullable Map insertedStackFrames, + List leadingStackFrames) { super( message, @@ -56,7 +57,8 @@ public final class VmUndefinedValueException extends VmEvalException { sourceSection, memberName, hintBuilder, - insertedStackFrames == null ? Collections.emptyMap() : insertedStackFrames); + insertedStackFrames == null ? Collections.emptyMap() : insertedStackFrames, + leadingStackFrames); this.receiver = receiver; } diff --git a/pkl-core/src/main/java/org/pkl/core/runtime/VmWrappedEvalException.java b/pkl-core/src/main/java/org/pkl/core/runtime/VmWrappedEvalException.java index 88ada6fac..16db32dcb 100644 --- a/pkl-core/src/main/java/org/pkl/core/runtime/VmWrappedEvalException.java +++ b/pkl-core/src/main/java/org/pkl/core/runtime/VmWrappedEvalException.java @@ -41,6 +41,7 @@ public class VmWrappedEvalException extends VmEvalException { @Nullable String memberName, @Nullable BiConsumer hintBuilder, Map insertedStackFrames, + List leadingStackFrames, VmException wrappedException) { super( message, @@ -53,7 +54,8 @@ public class VmWrappedEvalException extends VmEvalException { sourceSection, memberName, hintBuilder, - insertedStackFrames); + insertedStackFrames, + leadingStackFrames); this.wrappedException = wrappedException; } diff --git a/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference21.pkl b/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference21.pkl new file mode 100644 index 000000000..9c2699b47 --- /dev/null +++ b/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference21.pkl @@ -0,0 +1,7 @@ +import "pkl:ref" + +typealias Ref = ref.Reference + +typealias Ref2 = Ref + +foo: Ref2 diff --git a/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference22.pkl b/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference22.pkl new file mode 100644 index 000000000..ff2ebb1a2 --- /dev/null +++ b/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference22.pkl @@ -0,0 +1,6 @@ +import "pkl:ref" + +typealias Ref = ref.Reference +typealias Ref2 = Ref + +foo: Ref2 diff --git a/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference23.pkl b/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference23.pkl new file mode 100644 index 000000000..d57c86120 --- /dev/null +++ b/pkl-core/src/test/files/LanguageSnippetTests/input/errors/reference23.pkl @@ -0,0 +1,7 @@ + +import "pkl:ref" + +typealias Foo1 = Foo2 +typealias Foo2 = String(isEmpty) + +foo: ref.Reference diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference10.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference10.err index 461d5811a..6511baf11 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference10.err +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference10.err @@ -1,6 +1,10 @@ –– Pkl Error –– `Reference` referent type argument may not include type constraints. +x | typealias Ref = ref.Reference + ^^^^^^^^^^^^^^^^^^^ +at reference10#Ref (file:///$snippetsDir/input/errors/reference10.pkl) + x | test = ref.Reference(d, String, "") as Ref> ^^^^^^^^^^^^^^^^^^^^^^^^^^ at reference10#test (file:///$snippetsDir/input/errors/reference10.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference11.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference11.err index ac3607b2a..819e5efaf 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference11.err +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference11.err @@ -1,6 +1,18 @@ –– Pkl Error –– `Reference` referent type argument may not include type constraints. +xx | typealias Alias2 = String(length < 5) + ^^^^^^^^^^^^^^^^^^ +at reference11#Alias2 (file:///$snippetsDir/input/errors/reference11.pkl) + +xx | typealias Alias1 = Int | Alias2? + ^^^^^^ +at reference11#Alias1 (file:///$snippetsDir/input/errors/reference11.pkl) + +x | typealias Ref = ref.Reference + ^^^^^^^^^^^^^^^^^^^ +at reference11#Ref (file:///$snippetsDir/input/errors/reference11.pkl) + x | test = ref.Reference(d, String, "") as Ref ^^^^^^^^^^^^ at reference11#test (file:///$snippetsDir/input/errors/reference11.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference12.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference12.err index cde60de77..b14383b5f 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference12.err +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference12.err @@ -1,6 +1,10 @@ –– Pkl Error –– `Reference` referent type argument may not include type constraints. +xx | typealias Alias2 = String(length < 5) + ^^^^^^^^^^^^^^^^^^ +at reference12#Alias2 (file:///$snippetsDir/input/errors/reference12.pkl) + x | typealias RefAlias1 = ref.Reference ^^^^^^^^^^^^^^^^^^^^^^^^^ at reference12#RefAlias1 (file:///$snippetsDir/input/errors/reference12.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference21.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference21.err new file mode 100644 index 000000000..681349cee --- /dev/null +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference21.err @@ -0,0 +1,14 @@ +–– Pkl Error –– +`Reference` referent type argument may not include type constraints. + +x | typealias Ref = ref.Reference + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +at reference21#Ref (file:///$snippetsDir/input/errors/reference21.pkl) + +x | typealias Ref2 = Ref + ^^^^^^ +at reference21#Ref2 (file:///$snippetsDir/input/errors/reference21.pkl) + +x | foo: Ref2 + ^^^^^^^^^^^^^^^^^^^^^ +at reference21 (file:///$snippetsDir/input/errors/reference21.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference22.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference22.err new file mode 100644 index 000000000..fe0507e48 --- /dev/null +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference22.err @@ -0,0 +1,14 @@ +–– Pkl Error –– +`Reference` referent type argument may not include type constraints. + +x | typealias Ref = ref.Reference + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +at reference22#Ref (file:///$snippetsDir/input/errors/reference22.pkl) + +x | typealias Ref2 = Ref + ^^^^^^^^^^^^^^^ +at reference22#Ref2 (file:///$snippetsDir/input/errors/reference22.pkl) + +x | foo: Ref2 + ^^^^ +at reference22 (file:///$snippetsDir/input/errors/reference22.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference23.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference23.err new file mode 100644 index 000000000..2ea4f4c17 --- /dev/null +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference23.err @@ -0,0 +1,10 @@ +–– Pkl Error –– +`Reference` referent type argument may not include type constraints. + +x | typealias Foo2 = String(isEmpty) + ^^^^^^^^^^^^^^^ +at reference23#Foo2 (file:///$snippetsDir/input/errors/reference23.pkl) + +x | foo: ref.Reference + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +at reference23 (file:///$snippetsDir/input/errors/reference23.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference8.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference8.err index 206779e8c..0202ab797 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference8.err +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference8.err @@ -1,6 +1,10 @@ –– Pkl Error –– `Reference` referent type argument may not include type constraints. +x | typealias Ref = ref.Reference + ^^^^^^^^^^^^^^^^^^^ +at reference8#Ref (file:///$snippetsDir/input/errors/reference8.pkl) + x | test = ref.Reference(d, String, "") as Ref ^^^^^^^^^^^^^^^^^ at reference8#test (file:///$snippetsDir/input/errors/reference8.pkl) diff --git a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference9.err b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference9.err index fa24b00ea..4e48cfb79 100644 --- a/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference9.err +++ b/pkl-core/src/test/files/LanguageSnippetTests/output/errors/reference9.err @@ -1,6 +1,10 @@ –– Pkl Error –– `Reference` referent type argument may not include type constraints. +x | typealias Ref = ref.Reference + ^^^^^^^^^^^^^^^^^^^ +at reference9#Ref (file:///$snippetsDir/input/errors/reference9.pkl) + x | test = ref.Reference(d, String, "") as Ref ^^^^^^^^^^^^^^^^^^^^^^^ at reference9#test (file:///$snippetsDir/input/errors/reference9.pkl)