@apple/tree-sitter-pkl 0.17.0 → 0.18.1

package/grammar.js

@@ -1,11 +1,13 @@
-/**
- * Copyright © 2024 Apple Inc. and the Pkl project authors. All rights reserved.
+// noinspection JSUnusedLocalSymbols
+
+/*
+ * Copyright © 2024-2025 Apple Inc. and the Pkl project authors. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     https://www.apache.org/licenses/LICENSE-2.0
+ *   https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -13,12 +15,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 /// <reference path="node_modules/tree-sitter-cli/dsl.d.ts" />
 
-/**
- * Operator precedences
- */
+/** Precedences */
 const PREC = {
+  QUALIFIED_IDENTIFIER: 31,
+  DECLARED_TYPE: 30,
+  CONSTRAINED_TYPE: 30,
+  NULLABLE_TYPE: 29,
+  UNION_DEFAULT_TYPE: 29,
+  UNION_TYPE: 28,
+  FUN_TYPE: 27,
+
+  ACCESS: 22,
   NON_NULL: 21,
   NEG: 20,
   NOT: 19,
@@ -27,7 +37,7 @@ const PREC = {
   ADD: 16,
   REL: 15,
   IS: 14,
-  AS: 13,
+  AS: 14,
   EQ: 12,
   AND: 11,
   OR: 10,
@@ -39,18 +49,10 @@ const PREC = {
   THROW: -6,
   TRACE: -7,
   READ: -8,
-  READ_OR_NULL: -9,
-  READ_GLOB: -10,
   FUN: -11,
 
-  NULLABLE_TYPE: 5,
-  FUN_TYPE: -5,
-  UNION_DEFAULT_TYPE: -6,
-  UNION_TYPE: -7,
-
-  VAR_OBJ_LITERAL: 2,
-  OBJ_LITERAL: 1,
-  OBJ_MEMBER: -1
+  AMEND_EXPR: 1,
+  OBJ_MEMBER: -2,
 };
 
 const decimalLiteral = seq(/\d/, /[\d_]*/);
@@ -58,6 +60,59 @@ const decimalLiteral = seq(/\d/, /[\d_]*/);
 module.exports = grammar({
   name: 'pkl',
 
+  reserved: {
+    global: $ => [
+      '_',
+      'abstract',
+      'amends',
+      'as',
+      'class',
+      'const',
+      'else',
+      'extends',
+      'external',
+      'false',
+      'fixed',
+      'for',
+      'function',
+      'hidden',
+      'if',
+      'import',
+      'import*',
+      'in',
+      'is',
+      'let',
+      'local',
+      'module',
+      'new',
+      'nothing',
+      'null',
+      'open',
+      'out',
+      'outer',
+      'read',
+      'read*',
+      'read?',
+      'super',
+      'this',
+      'throw',
+      'trace',
+      'true',
+      'typealias',
+      'unknown',
+      'when',
+
+      // TODO support reserved keywords
+      // 'protected',
+      // 'override',
+      // 'record',
+      // 'delete',
+      // 'case',
+      // 'switch',
+      // 'vararg',
+    ]
+  },
+
   externals: $ => [
     $._sl_string_chars,
     $._sl1_string_chars,
@@ -77,6 +132,8 @@ module.exports = grammar({
     $._open_subscript_bracket,
     // '(' without preceding newline or semicolon
     $._open_argument_paren,
+    // '-' without preceding newline or semicolon
+    $._binary_minus,
   ],
 
   extras: $ => [
@@ -89,14 +146,8 @@ module.exports = grammar({
   word: $ => $.identifier,
 
   conflicts: $ => [
-    // these should be fixable in some other way (perhaps with prec)
-    [$.variableExpr, $.typedIdentifier],
-
-    // not sure what this one is about
-    [$.objectElement, $._expr],
-
-    [$.qualifiedIdentifier],
-    [$.declaredType]
+    [$.typedIdentifier, $.unqualifiedAccessExpr],
+    [$.qualifiedIdentifier]
   ],
 
   rules: {
@@ -182,7 +233,7 @@ module.exports = grammar({
       $.identifier,
       optional($.typeParameterList),
       "=",
-      $.type
+      $._type
     ),
 
     classProperty: $ => seq(
@@ -236,7 +287,7 @@ module.exports = grammar({
       $.objectMethod,
       $.objectEntry,
       $.objectElement,
-      $.objectPredicate,
+      $.memberPredicate,
       $.forGenerator,
       $.whenGenerator,
       $.objectSpread,
@@ -267,9 +318,9 @@ module.exports = grammar({
       )
     ),
 
-    objectElement: $ => choice($.variableExpr, $._expr2),
+    objectElement: $ => $._expr,
 
-    objectPredicate: $ => seq(
+    memberPredicate: $ => seq(
       "[[",
       field("conditionExpr", $._expr),
       "]]",
@@ -282,10 +333,10 @@ module.exports = grammar({
     forGenerator: $ => seq(
       "for",
       "(",
-      $.typedIdentifier,
+      $._parameter,
       optional(seq(
         ",",
-        $.typedIdentifier
+        $._parameter
       )),
       "in",
       $._expr,
@@ -316,13 +367,13 @@ module.exports = grammar({
     ),
 
     objectBodyParameters: $ => seq(
-      commaSep1($.typedIdentifier),
+      commaSep1($._parameter),
       "->"
     ),
 
-    typeAnnotation: $ => seq(":", $.type),
+    typeAnnotation: $ => seq(":", $._type),
 
-    type: $ => choice(
+    _type: $ => choice(
       alias("unknown", $.unknownType),
       alias("nothing", $.nothingType),
       alias("module", $.moduleType),
@@ -332,29 +383,37 @@ module.exports = grammar({
       $.nullableType,
       $.constrainedType,
       $.unionType,
-      $.unionDefaultType,
+      $.defaultUnionType,
       $.functionLiteralType
     ),
 
     stringLiteralType: $ => $.stringConstant,
 
-    declaredType: $ => seq($.qualifiedIdentifier, optional($.typeArgumentList)),
+    declaredType: $ => prec.right(PREC.DECLARED_TYPE, seq($.qualifiedIdentifier, optional($.typeArgumentList))),
 
-    parenthesizedType: $ => seq("(", $.type, ")"),
+    parenthesizedType: $ => seq("(", $._type, ")"),
 
-    nullableType: $ => prec(PREC.NULLABLE_TYPE, seq($.type, "?")),
+    nullableType: $ => prec(PREC.NULLABLE_TYPE, seq($._type, "?")),
 
-    constrainedType: $ => seq($.type, "(", commaSep1($._expr), ")"),
+    constrainedType: $ => prec.right(
+      PREC.CONSTRAINED_TYPE,
+      seq(
+        $._type,
+        alias($._open_argument_paren, '('),
+        commaSep1($._expr),
+        ")"
+      )
+    ),
 
-    unionType: $ => prec.left(PREC.UNION_TYPE, seq($.type, "|", $.type)),
+    unionType: $ => prec.left(PREC.UNION_TYPE, seq($._type, "|", $._type)),
 
-    unionDefaultType: $ => prec(PREC.UNION_DEFAULT_TYPE, seq("*", $.type)),
+    defaultUnionType: $ => prec.left(PREC.UNION_DEFAULT_TYPE, seq("*", $._type)),
 
-    functionLiteralType: $ => prec(PREC.FUN_TYPE, seq("(", commaSep($.type), ")", "->", $.type)),
+    functionLiteralType: $ => prec(PREC.FUN_TYPE, seq("(", commaSep($._type), ")", "->", $._type)),
 
     typeArgumentList: $ => seq(
       "<",
-      commaSep1($.type),
+      commaSep1($._type),
       ">"
     ),
 
@@ -371,10 +430,16 @@ module.exports = grammar({
 
     parameterList: $ => seq(
       '(',
-      commaSep($.typedIdentifier),
+      commaSep($._parameter),
       ')'
     ),
 
+    _parameter: $ => choice($.typedIdentifier, $.blankIdentifier),
+
+    typedIdentifier: $ => seq($.identifier, optional($.typeAnnotation)),
+
+    blankIdentifier: $ => "_",
+
     argumentList: $ => seq(
       alias($._open_argument_paren, '('),
       commaSep($._expr),
@@ -392,48 +457,45 @@ module.exports = grammar({
     ),
 
     _expr: $ => choice(
-      $.variableExpr,
-      $.variableObjectLiteral,
-      $._expr2
-    ),
-
-    variableObjectLiteral: $ => prec(PREC.VAR_OBJ_LITERAL, seq(
-      $.identifier,
-      $.objectBody
-    )),
-
-    _expr2: $ => choice(
-      $.parenthesizedExpr,
       $.thisExpr,
       $.outerExpr,
       $.moduleExpr,
-      $.nullLiteral,
-      $.trueLiteral,
-      $.falseLiteral,
-      $.intLiteral,
-      $.floatLiteral,
-      $.slStringLiteral,
-      $.mlStringLiteral,
+      $.nullLiteralExpr,
+      $.trueLiteralExpr,
+      $.falseLiteralExpr,
+      $.intLiteralExpr,
+      $.floatLiteralExpr,
+      $.throwExpr,
+      $.traceExpr,
+      $.importExpr,
+      $.readExpr,
+      $.unqualifiedAccessExpr,
+      $.slStringLiteralExpr,
+      $.mlStringLiteralExpr,
       $.newExpr,
-      $.objectLiteral,
-      $.methodCallExpr,
-      $.propertyCallExpr,
+      $.amendExpr,
+      $.superAccessExpr,
+      $.superSubscriptExpr,
+      $.qualifiedAccessExpr,
       $.subscriptExpr,
-      $.unaryExpr,
-      $.binaryExpr,
-      $.binaryExprRightAssoc,
-      $.isExpr,
-      $.asExpr,
+      $.nonNullExpr,
+      $.unaryMinusExpr,
+      $.logicalNotExpr,
+      $.exponentiationExpr,
+      $.multiplicativeExpr,
+      $.additiveExpr,
+      $.comparisonExpr,
+      $.typeTestExpr,
+      $.typeCastExpr,
+      $.equalityExpr,
+      $.logicalAndExpr,
+      $.logicalOrExpr,
+      $.pipeExpr,
+      $.nullCoalesceExpr,
       $.ifExpr,
       $.letExpr,
-      $.throwExpr,
-      $.traceExpr,
-      $.readExpr,
-      $.readOrNullExpr,
-      $.readGlobExpr,
-      $.importExpr,
-      $.importGlobExpr,
-      $.functionLiteral
+      $.functionLiteralExpr,
+      $.parenthesizedExpr,
     ),
 
     parenthesizedExpr: $ => seq("(", $._expr, ")"),
@@ -444,15 +506,13 @@ module.exports = grammar({
 
     moduleExpr: $ => "module",
 
-    variableExpr: $ => $.identifier,
+    nullLiteralExpr: $ => "null",
 
-    nullLiteral: $ => "null",
+    trueLiteralExpr: $ => "true",
 
-    trueLiteral: $ => "true",
+    falseLiteralExpr: $ => "false",
 
-    falseLiteral: $ => "false",
-
-    intLiteral: $ => {
+    intLiteralExpr: $ => {
       return token(choice(
         decimalLiteral,
         seq('0x', /[\da-fA-F]/, /[\da-fA-F_]*/),
@@ -461,7 +521,7 @@ module.exports = grammar({
       ))
     },
 
-    floatLiteral: $ => {
+    floatLiteralExpr: $ => {
       const exponent = seq(choice('e', 'E'), optional(choice('+', '-')), decimalLiteral)
       return token(choice(
         seq(optional(decimalLiteral), '.', decimalLiteral, optional(exponent)),
@@ -488,13 +548,13 @@ module.exports = grammar({
       )
     ),
 
-    slStringLiteral: $ => choice(
+    slStringLiteralExpr: $ => choice(
       seq(
         '"',
         repeat(choice(
           $.slStringLiteralPart,
           $.escapeSequence,
-          $.interpolationExpr,
+          $.stringInterpolation,
         )),
         '"'
       ),
@@ -503,7 +563,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.slStringLiteralPart1, $.slStringLiteralPart),
           alias($.escapeSequence1, $.escapeSequence),
-          alias($.interpolationExpr1, $.interpolationExpr)
+          alias($.stringInterpolation1, $.stringInterpolation)
         )),
         '"#'
       ),
@@ -512,7 +572,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.slStringLiteralPart2, $.slStringLiteralPart),
           alias($.escapeSequence2, $.escapeSequence),
-          alias($.interpolationExpr2, $.interpolationExpr)
+          alias($.stringInterpolation2, $.stringInterpolation)
         )),
         '"##'
       ),
@@ -521,7 +581,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.slStringLiteralPart3, $.slStringLiteralPart),
           alias($.escapeSequence3, $.escapeSequence),
-          alias($.interpolationExpr3, $.interpolationExpr)
+          alias($.stringInterpolation3, $.stringInterpolation)
         )),
         '"###'
       ),
@@ -530,7 +590,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.slStringLiteralPart4, $.slStringLiteralPart),
           alias($.escapeSequence4, $.escapeSequence),
-          alias($.interpolationExpr4, $.interpolationExpr)
+          alias($.stringInterpolation4, $.stringInterpolation)
         )),
         '"####'
       ),
@@ -539,7 +599,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.slStringLiteralPart5, $.slStringLiteralPart),
           alias($.escapeSequence5, $.escapeSequence),
-          alias($.interpolationExpr5, $.interpolationExpr)
+          alias($.stringInterpolation5, $.stringInterpolation)
         )),
         '"#####'
       ),
@@ -548,7 +608,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.slStringLiteralPart6, $.slStringLiteralPart),
           alias($.escapeSequence6, $.escapeSequence),
-          alias($.interpolationExpr6, $.interpolationExpr)
+          alias($.stringInterpolation6, $.stringInterpolation)
         )),
         '"######'
       ),
@@ -568,13 +628,13 @@ module.exports = grammar({
 
     slStringLiteralPart6: $ => $._sl6_string_chars,
 
-    mlStringLiteral: $ => choice(
+    mlStringLiteralExpr: $ => choice(
       seq(
         '"""',
         repeat(choice(
           $.mlStringLiteralPart,
           $.escapeSequence,
-          $.interpolationExpr
+          $.stringInterpolation
         )),
         '"""'
       ),
@@ -583,7 +643,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.mlStringLiteralPart1, $.mlStringLiteralPart),
           alias($.escapeSequence1, $.escapeSequence),
-          alias($.interpolationExpr1, $.interpolationExpr)
+          alias($.stringInterpolation1, $.stringInterpolation)
         )),
         '"""#'
       ),
@@ -592,7 +652,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.mlStringLiteralPart2, $.mlStringLiteralPart),
           alias($.escapeSequence2, $.escapeSequence),
-          alias($.interpolationExpr2, $.interpolationExpr)
+          alias($.stringInterpolation2, $.stringInterpolation)
         )),
         '"""##'
       ),
@@ -601,7 +661,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.mlStringLiteralPart3, $.mlStringLiteralPart),
           alias($.escapeSequence3, $.escapeSequence),
-          alias($.interpolationExpr3, $.interpolationExpr)
+          alias($.stringInterpolation3, $.stringInterpolation)
         )),
         '"""###'
       ),
@@ -610,7 +670,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.mlStringLiteralPart4, $.mlStringLiteralPart),
           alias($.escapeSequence4, $.escapeSequence),
-          alias($.interpolationExpr4, $.interpolationExpr)
+          alias($.stringInterpolation4, $.stringInterpolation)
         )),
         '"""####'
       ),
@@ -619,7 +679,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.mlStringLiteralPart5, $.mlStringLiteralPart),
           alias($.escapeSequence5, $.escapeSequence),
-          alias($.interpolationExpr5, $.interpolationExpr)
+          alias($.stringInterpolation5, $.stringInterpolation)
         )),
         '"""#####'
       ),
@@ -628,7 +688,7 @@ module.exports = grammar({
         repeat(choice(
           alias($.mlStringLiteralPart6, $.mlStringLiteralPart),
           alias($.escapeSequence6, $.escapeSequence),
-          alias($.interpolationExpr6, $.interpolationExpr)
+          alias($.stringInterpolation6, $.stringInterpolation)
         )),
         '"""######'
       ),
@@ -652,7 +712,7 @@ module.exports = grammar({
       '\\',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
@@ -660,7 +720,7 @@ module.exports = grammar({
       '\\#',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
@@ -668,7 +728,7 @@ module.exports = grammar({
       '\\##',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
@@ -676,7 +736,7 @@ module.exports = grammar({
       '\\###',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
@@ -684,7 +744,7 @@ module.exports = grammar({
       '\\####',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
@@ -692,7 +752,7 @@ module.exports = grammar({
       '\\#####',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
@@ -700,125 +760,95 @@ module.exports = grammar({
       '\\######',
       choice(
         /[tnr\\"]/,
-        /u\{[0-9a-fA-F]+\}/
+        /u\{[0-9a-fA-F]+}/
       )
     )),
 
-    interpolationExpr: $ => seq(token.immediate("\\("), $._expr, ")"),
+    stringInterpolation: $ => seq(token.immediate("\\("), $._expr, ")"),
 
-    interpolationExpr1: $ => seq(token.immediate("\\#("), $._expr, ")"),
+    stringInterpolation1: $ => seq(token.immediate("\\#("), $._expr, ")"),
 
-    interpolationExpr2: $ => seq(token.immediate("\\##("), $._expr, ")"),
+    stringInterpolation2: $ => seq(token.immediate("\\##("), $._expr, ")"),
 
-    interpolationExpr3: $ => seq(token.immediate("\\###("), $._expr, ")"),
+    stringInterpolation3: $ => seq(token.immediate("\\###("), $._expr, ")"),
 
-    interpolationExpr4: $ => seq(token.immediate("\\####("), $._expr, ")"),
+    stringInterpolation4: $ => seq(token.immediate("\\####("), $._expr, ")"),
 
-    interpolationExpr5: $ => seq(token.immediate("\\#####("), $._expr, ")"),
+    stringInterpolation5: $ => seq(token.immediate("\\#####("), $._expr, ")"),
 
-    interpolationExpr6: $ => seq(token.immediate("\\######("), $._expr, ")"),
+    stringInterpolation6: $ => seq(token.immediate("\\######("), $._expr, ")"),
 
-    newExpr: $ => seq("new", optional($.type), $.objectBody),
+    newExpr: $ => seq("new", optional($._type), $.objectBody),
 
-    objectLiteral: $ => prec(PREC.OBJ_LITERAL, seq($._expr2, $.objectBody)),
+    amendExpr: $ => prec(PREC.AMEND_EXPR, seq(field("parent", choice($.newExpr, $.amendExpr, $.parenthesizedExpr)), $.objectBody)),
 
-    methodCallExpr: $ => seq(
-        optional(
-            seq(
-                field("receiver", choice("super", $._expr)),
-                choice(".", "?.")
-            )
-        ),
-        $.identifier,
-        $.argumentList
-    ),
+    subscriptExpr: $ => prec.left(PREC.ACCESS, seq(field("receiver", $._expr), alias($._open_subscript_bracket, "["), $._expr, "]")),
 
-    propertyCallExpr: $ => seq(
-        field("receiver", choice("super", $._expr)),
-        choice(".", "?."),
-        // allow newline as a possible token because tree-sitter otherwise doesn't handle error recovery correctly.
-        // E.g.
-        // This gets parsed as a single class property, where `bar.baz { foo = bar }` is the property's value
-        // ```
-        // foo = bar.
-        // baz { foo = bar }
-        // ```
-        //
-        // This gets parsed as two class properties; `foo = bar.typealias` and `Baz = String`
-        // ```
-        // foo = bar.
-        //
-        // typealias Baz = String
-        // ```
-        choice($.identifier, field("err", "\n"))
-    ),
-
-    subscriptExpr: $ => seq(field("receiver", choice("super", $._expr)), alias($._open_subscript_bracket, "["), $._expr, "]"),
-
-    unaryExpr: $ => choice(
-      prec.left(PREC.NEG, seq($._expr, '!!')),
-      prec.left(PREC.NEG, seq('-', $._expr)),
-      prec.left(PREC.NOT, seq('!', $._expr)),
-    ),
-
-    binaryExprRightAssoc: $ => choice(...[
-      ['**', PREC.EXP],
-      ['??', PREC.COALESCE]
-    ].map(([operator, precedence]) =>
-      prec.right(precedence, seq($._expr, field('operator', operator), $._expr))
-    )),
+    unaryMinusExpr: $ => prec.left(PREC.NEG, seq('-', $._expr)),
 
-    binaryExpr: $ => choice(...[
-      ['*', PREC.MUL],
-      ['/', PREC.MUL],
-      ['~/', PREC.MUL],
-      ['%', PREC.MUL],
-      ['+', PREC.ADD],
-      ['-', PREC.ADD],
-      ['<', PREC.REL],
-      ['<=', PREC.REL],
-      ['>=', PREC.REL],
-      ['>', PREC.REL],
-      ['==', PREC.EQ],
-      ['!=', PREC.EQ],
-      ['&&', PREC.AND],
-      ['||', PREC.OR],
-      ['|>', PREC.PIPE]
-    ].map(([operator, precedence]) =>
-      prec.left(precedence, seq($._expr, field('operator', operator), $._expr))
-    )),
+    logicalNotExpr: $ => prec.left(PREC.NOT, seq('!', $._expr)),
+
+    nonNullExpr: $ => prec.left(PREC.NON_NULL, seq($._expr, "!!")),
+
+    nullCoalesceExpr: $ => prec.right(PREC.COALESCE, seq($._expr, field('operator', '??'), $._expr)),
+
+    exponentiationExpr: $ => prec.right(PREC.EXP, seq($._expr, field('operator', '**'), $._expr)),
+
+    multiplicativeExpr: $ => prec.left(PREC.MUL, seq($._expr, field('operator', choice("*", "/", "~/", "%")), $._expr)),
+
+    additiveExpr: $ => prec.left(PREC.ADD, seq($._expr, field('operator', choice("+", alias($._binary_minus, "-"))), $._expr)),
+
+    comparisonExpr: $ => prec.left(PREC.REL, seq($._expr, field('operator', choice("<", "<=", ">=", ">")), $._expr)),
 
-    isExpr: $ => prec(PREC.IS, seq($._expr, "is", $.type)),
+    equalityExpr: $ => prec.left(PREC.EQ, seq($._expr, field('operator', choice("==", "!=")), $._expr)),
 
-    asExpr: $ => prec(PREC.IS, seq($._expr, "as", $.type)),
+    logicalAndExpr: $ => prec.left(PREC.AND, seq($._expr, field('operator', "&&"), $._expr)),
+
+    logicalOrExpr: $ => prec.left(PREC.OR, seq($._expr, field('operator', "||"), $._expr)),
+    
+    pipeExpr: $ => prec.left(PREC.PIPE, seq($._expr, field('operator', "|>"), $._expr)),
+
+    typeTestExpr: $ => prec(PREC.IS, seq($._expr, field("operator", "is"), $._type)),
+
+    typeCastExpr: $ => prec(PREC.AS, seq($._expr, field("operator", "as"), $._type)),
 
     ifExpr: $ => prec(PREC.IF, seq("if", "(", $._expr, ")", $._expr, "else", $._expr)),
 
-    letExpr: $ => prec(PREC.LET, seq("let", "(", $.typedIdentifier, "=", $._expr, ")", $._expr)),
+    letExpr: $ => prec(PREC.LET, seq("let", "(", $._parameter, "=", $._expr, ")", $._expr)),
 
-    throwExpr: $ => prec(PREC.THROW, seq("throw", $._expr)),
+    throwExpr: $ => prec(PREC.THROW, seq("throw", '(', $._expr, ')')),
 
-    traceExpr: $ => prec(PREC.TRACE, seq("trace", $._expr)),
+    traceExpr: $ => prec(PREC.TRACE, seq("trace", '(', $._expr, ')')),
 
-    readExpr: $ => prec(PREC.READ, seq("read", $._expr)),
+    readExpr: $ => prec(PREC.READ, seq(field("variant", choice("read", "read?", "read*")), '(', $._expr, ')')),
 
-    readOrNullExpr: $ => prec(PREC.READ_OR_NULL, seq("read?", $._expr)),
+    importExpr: $ => seq(field("variant", choice("import", "import*")), seq('(', $.stringConstant, ')')),
 
-    readGlobExpr: $ => prec(PREC.READ_GLOB, seq("read*", $._expr)),
+    unqualifiedAccessExpr: $ => seq($.identifier, optional($.argumentList)),
 
-    importExpr: $ => seq("import", seq('(', $.stringConstant, ')')),
+    superAccessExpr: $ => prec.left(PREC.ACCESS, seq("super", ".", $.identifier, optional($.argumentList))),
 
-    importGlobExpr: $ => seq("import*", seq('(', $.stringConstant, ')')),
+    superSubscriptExpr: $ => prec.left(PREC.ACCESS, seq("super", alias($._open_subscript_bracket, "["), $._expr, "]")),
 
-    functionLiteral: $ => prec(PREC.FUN, seq($.parameterList, "->", $._expr)),
+    qualifiedAccessExpr: $ => prec.left(
+      PREC.ACCESS,
+      seq(
+        field("receiver", $._expr),
+        choice(".", "?."),
+        seq(
+          $.identifier,
+          optional($.argumentList)
+        ),
+      )
+    ),
+
+    functionLiteralExpr: $ => prec(PREC.FUN, seq($.parameterList, "->", $._expr)),
 
     qualifiedIdentifier: $ => seq(
       $.identifier,
       repeat(seq(".", $.identifier)),
     ),
 
-    typedIdentifier: $ => seq($.identifier, optional($.typeAnnotation)),
-
     // TODO: adapt to pkl
     identifier: $ => {
       const alpha = /[^\s0-9:;`"'@#.,|^&<=>+\-*/\\%?!~()\[\]{}\uFEFF\u2060\u200B\u00A0]/
@@ -842,7 +872,7 @@ module.exports = grammar({
       '/*',
       /[^*]*\*+([^/*][^*]*\*+)*/,
       '/'
-    ))
+    )),
   }
 });