@openrewrite/rewrite 8.96.2 → 8.96.4

package/package.json

@@ -1,108 +1,106 @@
 {
-  "name": "@openrewrite/rewrite",
-  "version": "8.96.2",
-  "license": "Moderne Source Available License",
-  "description": "OpenRewrite JavaScript.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/openrewrite/rewrite",
-    "directory": "rewrite-javascript/rewrite"
+  "name" : "@openrewrite/rewrite",
+  "version" : "8.96.4",
+  "license" : "Moderne Source Available License",
+  "description" : "OpenRewrite JavaScript.",
+  "repository" : {
+    "type" : "git",
+    "url" : "https://github.com/openrewrite/rewrite",
+    "directory" : "rewrite-javascript/rewrite"
   },
-  "homepage": "https://github.com/openrewrite/rewrite",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/**",
-    "src/**"
-  ],
-  "allowScripts": {
-    "bun": true,
-    "@datadog/pprof": true
+  "homepage" : "https://github.com/openrewrite/rewrite",
+  "main" : "./dist/index.js",
+  "types" : "./dist/index.d.ts",
+  "files" : [ "dist/**", "src/**" ],
+  "allowScripts" : {
+    "bun" : true,
+    "@datadog/pprof" : true
   },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+  "exports" : {
+    "." : {
+      "types" : "./dist/index.d.ts",
+      "default" : "./dist/index.js"
     },
-    "./text": {
-      "types": "./dist/text/index.d.ts",
-      "default": "./dist/text/index.js"
+    "./text" : {
+      "types" : "./dist/text/index.d.ts",
+      "default" : "./dist/text/index.js"
     },
-    "./json": {
-      "types": "./dist/json/index.d.ts",
-      "default": "./dist/json/index.js"
+    "./json" : {
+      "types" : "./dist/json/index.d.ts",
+      "default" : "./dist/json/index.js"
     },
-    "./java": {
-      "types": "./dist/java/index.d.ts",
-      "default": "./dist/java/index.js"
+    "./java" : {
+      "types" : "./dist/java/index.d.ts",
+      "default" : "./dist/java/index.js"
     },
-    "./javascript": {
-      "types": "./dist/javascript/index.d.ts",
-      "default": "./dist/javascript/index.js"
+    "./javascript" : {
+      "types" : "./dist/javascript/index.d.ts",
+      "default" : "./dist/javascript/index.js"
     },
-    "./rpc": {
-      "types": "./dist/rpc/index.d.ts",
-      "default": "./dist/rpc/index.js"
+    "./rpc" : {
+      "types" : "./dist/rpc/index.d.ts",
+      "default" : "./dist/rpc/index.js"
     },
-    "./test": {
-      "types": "./dist/test/index.d.ts",
-      "default": "./dist/test/index.js"
+    "./test" : {
+      "types" : "./dist/test/index.d.ts",
+      "default" : "./dist/test/index.js"
     },
-    "./test/java-rpc": {
-      "types": "./dist/test/java-rpc.d.ts",
-      "default": "./dist/test/java-rpc.js"
+    "./test/java-rpc" : {
+      "types" : "./dist/test/java-rpc.d.ts",
+      "default" : "./dist/test/java-rpc.js"
     },
-    "./yaml": {
-      "types": "./dist/yaml/index.d.ts",
-      "default": "./dist/yaml/index.js"
+    "./yaml" : {
+      "types" : "./dist/yaml/index.d.ts",
+      "default" : "./dist/yaml/index.js"
     }
   },
-  "scripts": {
-    "prebuild": "bun -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && bun -e \"require('fs').rmSync('tsconfig.build.tsbuildinfo',{force:true})\"",
-    "build": "tsc --build tsconfig.build.json",
-    "postbuild": "bun -e \"require('fs').chmodSync('dist/rpc/server.js', 0o755); require('fs').chmodSync('dist/javascript/type-report-cli.js', 0o755)\" && npm link --no-audit --no-fund --loglevel=warn",
-    "typecheck": "tsc --noEmit -p tsconfig.test.json",
-    "dev": "tsc --watch -p tsconfig.json",
-    "test": "npm run typecheck && npm run build && vitest run",
-    "testhelper": "vitest run",
-    "build:fixtures": "tsc --build fixtures/tsconfig.json",
-    "start": "npm run build && node ./dist/rpc/server.js"
+  "scripts" : {
+    "prebuild" : "bun -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && bun -e \"require('fs').rmSync('tsconfig.build.tsbuildinfo',{force:true})\"",
+    "build" : "tsc --build tsconfig.build.json",
+    "postbuild" : "bun -e \"require('fs').chmodSync('dist/rpc/server.js', 0o755); require('fs').chmodSync('dist/javascript/type-report-cli.js', 0o755)\" && npm link --no-audit --no-fund --loglevel=warn",
+    "typecheck" : "tsc --noEmit -p tsconfig.test.json",
+    "dev" : "tsc --watch -p tsconfig.json",
+    "test" : "npm run typecheck && npm run build && vitest run",
+    "testhelper" : "vitest run",
+    "build:fixtures" : "tsc --build fixtures/tsconfig.json",
+    "start" : "npm run build && node ./dist/rpc/server.js"
   },
-  "dependencies": {
-    "@akashrajpurohit/snowflake-id": "^2.0.0",
-    "@types/node": "^22.5.4",
-    "commander": "^10.0.1",
-    "diff": "^8.0.0",
-    "jsonc-parser": "^3.3.1",
-    "mutative": "^1.3.0",
-    "picomatch": "^4.0.4",
-    "semver": "^7.7.4",
-    "tmp-promise": "^3.0.3",
-    "typescript": "^6.0.3",
-    "vscode-jsonrpc": "^8.2.1",
-    "yaml": "^2.9.0"
+  "dependencies" : {
+    "@akashrajpurohit/snowflake-id" : "^2.0.0",
+    "@types/node" : "^22.5.4",
+    "commander" : "^10.0.1",
+    "diff" : "^8.0.0",
+    "jsonc-parser" : "^3.3.1",
+    "mutative" : "^1.3.0",
+    "picomatch" : "4.0.8-backpatch-00001",
+    "semver" : "^7.7.4",
+    "tmp-promise" : "^3.0.3",
+    "typescript" : "^6.0.3",
+    "vscode-jsonrpc" : "^8.2.1",
+    "yaml" : "^2.9.0"
   },
-  "devDependencies": {
-    "@types/benchmark": "^2.1.5",
-    "@types/diff": "^8.0.0",
-    "@types/picomatch": "^4.0.2",
-    "@types/semver": "^7.7.1",
-    "@types/tmp": "^0.2.6",
-    "benchmark": "^2.1.4",
-    "bun": "^1.3.5",
-    "prettier": "^3.7.4",
-    "vitest": "^4.1.8"
+  "devDependencies" : {
+    "@types/benchmark" : "^2.1.5",
+    "@types/diff" : "^8.0.0",
+    "@types/picomatch" : "^4.0.2",
+    "@types/semver" : "^7.7.1",
+    "@types/tmp" : "^0.2.6",
+    "benchmark" : "^2.1.4",
+    "bun" : "^1.3.5",
+    "prettier" : "^3.7.4",
+    "vitest" : "^4.1.8"
   },
-  "optionalDependencies": {
-    "@pyroscope/nodejs": "^0.4.0",
-    "prettier": "^3.7.4"
+  "optionalDependencies" : {
+    "@pyroscope/nodejs" : "^0.4.0",
+    "prettier" : "^3.7.4"
   },
-  "overrides": {
-    "tmp": "^0.2.7",
-    "lodash": "^4.18.1"
+  "overrides" : {
+    "tmp" : "^0.2.7",
+    "lodash" : "^4.18.1"
   },
-  "bin": {
-    "rewrite-rpc": "./dist/rpc/server.js",
-    "rewrite-javascript-types": "./dist/javascript/type-report-cli.js"
-  }
-}
+  "bin" : {
+    "rewrite-rpc" : "./dist/rpc/server.js",
+    "rewrite-javascript-types" : "./dist/javascript/type-report-cli.js"
+  },
+  "bundleDependencies" : [ "picomatch" ]
+}

package/src/java/tree.ts

@@ -267,7 +267,7 @@ export namespace J {
         }
     }
 
-    export interface Block extends J {
+    export interface Block extends J, Statement {
         readonly kind: typeof Kind.Block;
         readonly static: RightPadded<boolean>;
         readonly statements: RightPadded<Statement>[];
@@ -426,7 +426,7 @@ export namespace J {
         }
     }
 
-    export interface Import extends J {
+    export interface Import extends J, Statement {
         readonly kind: typeof Kind.Import;
         readonly static: LeftPadded<boolean>;
         readonly qualid: FieldAccess;
@@ -442,7 +442,7 @@ export namespace J {
         readonly modifier?: Modifier;
     }
 
-    export interface DeconstructionPattern extends J, TypedTree {
+    export interface DeconstructionPattern extends J, Expression, TypedTree {
         readonly kind: typeof Kind.DeconstructionPattern;
         readonly deconstructor: Expression;
         readonly nested: Container<J>;
@@ -490,7 +490,7 @@ export namespace J {
         readonly codePoint: string;
     }
 
-    export interface MemberReference extends J, MethodCall {
+    export interface MemberReference extends J, TypedTree, MethodCall {
         readonly kind: typeof Kind.MemberReference;
         readonly containing: RightPadded<Expression>;
         readonly typeParameters?: Container<Expression>;
@@ -499,7 +499,7 @@ export namespace J {
         readonly variableType?: Type.Variable;
     }
 
-    export interface MethodDeclaration extends J, TypedTree {
+    export interface MethodDeclaration extends J, Statement, TypedTree {
         readonly kind: typeof Kind.MethodDeclaration;
         readonly leadingAnnotations: Annotation[];
         readonly modifiers: Modifier[];
@@ -515,7 +515,7 @@ export namespace J {
         readonly methodType?: Type.Method;
     }
 
-    export interface MethodInvocation extends J, TypedTree, MethodCall {
+    export interface MethodInvocation extends J, Statement, TypedTree, MethodCall {
         readonly kind: typeof Kind.MethodInvocation;
         readonly select?: RightPadded<Expression>;
         readonly typeParameters?: Container<Expression>;
@@ -567,7 +567,7 @@ export namespace J {
         readonly type?: Type;
     }
 
-    export interface NewClass extends J, TypedTree, MethodCall {
+    export interface NewClass extends J, Statement, TypedTree, MethodCall {
         readonly kind: typeof Kind.NewClass;
         readonly enclosing?: RightPadded<Expression>;
         readonly new: Space;
@@ -583,13 +583,13 @@ export namespace J {
         readonly typeTree: RightPadded<TypeTree>;
     }
 
-    export interface Package extends J {
+    export interface Package extends J, Statement {
         readonly kind: typeof Kind.Package;
         readonly expression: Expression;
         readonly annotations?: Annotation[];
     }
 
-    export interface ParameterizedType extends J, TypeTree {
+    export interface ParameterizedType extends J, TypeTree, Expression {
         readonly kind: typeof Kind.ParameterizedType;
         readonly class: NameTree;
         readonly typeParameters?: Container<Expression>;
@@ -711,7 +711,7 @@ export namespace J {
         }
     }
 
-    export interface VariableDeclarations extends J, TypedTree {
+    export interface VariableDeclarations extends J, Statement, TypedTree {
         readonly kind: typeof Kind.VariableDeclarations;
         readonly leadingAnnotations: Annotation[];
         readonly modifiers: Modifier[];
@@ -721,7 +721,7 @@ export namespace J {
     }
 
     export namespace VariableDeclarations {
-        export interface NamedVariable extends J {
+        export interface NamedVariable extends J, NameTree {
             readonly kind: typeof Kind.NamedVariable;
             readonly name: VariableDeclarator;
             readonly dimensionsAfterName: LeftPadded<Space>[];

package/src/java/visitor.ts

@@ -199,6 +199,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         }
         assignOp = expression as J.AssignmentOperation;
 
+        const statement = await this.visitStatement(assignOp, p);
+        if (!statement?.kind || statement.kind !== J.Kind.AssignmentOperation) {
+            return statement;
+        }
+        assignOp = statement as J.AssignmentOperation;
+
         const updates = {
             prefix: await this.visitSpace(assignOp.prefix, p),
             markers: await this.visitMarkers(assignOp.markers, p),
@@ -229,6 +235,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitBlock(block: J.Block, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(block, p);
+        if (!statement?.kind || statement.kind !== J.Kind.Block) {
+            return statement;
+        }
+        block = statement as J.Block;
+
         const updates = {
             prefix: await this.visitSpace(block.prefix, p),
             markers: await this.visitMarkers(block.markers, p),
@@ -340,6 +352,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitControlParentheses<T extends J>(controlParens: J.ControlParentheses<T>, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(controlParens, p);
+        if (!expression?.kind || expression.kind !== J.Kind.ControlParentheses) {
+            return expression;
+        }
+        controlParens = expression as J.ControlParentheses<T>;
+
         const updates: any = {
             prefix: await this.visitSpace(controlParens.prefix, p),
             markers: await this.visitMarkers(controlParens.markers, p),
@@ -797,6 +815,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         }
         newClass = expression as J.NewClass;
 
+        const statement = await this.visitStatement(newClass, p);
+        if (!statement?.kind || statement.kind !== J.Kind.NewClass) {
+            return statement;
+        }
+        newClass = statement as J.NewClass;
+
         const updates: any = {
             prefix: await this.visitSpace(newClass.prefix, p),
             markers: await this.visitMarkers(newClass.markers, p),
@@ -845,6 +869,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitParameterizedType(parameterizedType: J.ParameterizedType, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(parameterizedType, p);
+        if (!expression?.kind || expression.kind !== J.Kind.ParameterizedType) {
+            return expression;
+        }
+        parameterizedType = expression as J.ParameterizedType;
+
         const updates: any = {
             prefix: await this.visitSpace(parameterizedType.prefix, p),
             markers: await this.visitMarkers(parameterizedType.markers, p),
@@ -856,6 +886,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitParentheses<T extends J>(parentheses: J.Parentheses<T>, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(parentheses, p);
+        if (!expression?.kind || expression.kind !== J.Kind.Parentheses) {
+            return expression;
+        }
+        parentheses = expression as J.Parentheses<T>;
+
         const updates: any = {
             prefix: await this.visitSpace(parentheses.prefix, p),
             markers: await this.visitMarkers(parentheses.markers, p),

package/src/javascript/add-import.ts

@@ -8,7 +8,7 @@ import {moduleName, packageNameOf, sameModule, spelledLike} from "./package-name
 import {emptyMarkers, findMarker, markers, MarkersKind} from "../markers";
 import {NamedStyles} from "../style";
 import {getStyle, SpacesStyle, StyleKind} from "./style";
-import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, namesDeclaredIn, resolve, scopeOf, walk} from "./scope";
+import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, isFree, namesDeclaredIn, resolve, scopeOf, walk} from "./scope";
 import {create as produce, Draft} from "mutative";
 import {autoFormat} from "./format";
 import {getPrettierStyle} from "./format/prettier-format";
@@ -1346,14 +1346,13 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         const self = this;
         const matchesModule = (name: string | undefined) =>
             name !== undefined && (name === expectedDeclaringType || name === targetModule);
-        const alreadyBound = moduleScopeBindings(compilationUnit).some(b => b.name === targetName);
 
         // If no existing imports from this module, look for unresolved references
         // If there ARE existing imports, look for references with the expected declaring type
 
         const collector = new class extends JavaScriptVisitor<void> {
             override async visitIdentifier(identifier: J.Identifier, p: void): Promise<J | undefined> {
-                if (identifier.simpleName === targetName) {
+                if (!found && identifier.simpleName === targetName && isFree(this.cursor, identifier)) {
                     const type = identifier.type;
                     const fieldType = identifier.fieldType;
                     if (expectedDeclaringType) {
@@ -1364,7 +1363,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                                 found = true;
                             }
                         }
-                        else if (!alreadyBound && type && Type.isClass(type)) {
+                        else if (type && Type.isClass(type)) {
                             if (self.classTypeMatchesModule(type as Type.Class, expectedDeclaringType) ||
                                 self.classTypeMatchesModule(type as Type.Class, targetModule)) {
                                 found = true;
@@ -1417,7 +1416,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                             }
                         }
                         // 4. References typed as the module's namespace object (e.g. `z` from zod)
-                        else if (!alreadyBound && type && Type.isClass(type) &&
+                        else if (type && Type.isClass(type) &&
                             sameModule((type as Type.Class).fullyQualifiedName, targetModule)) {
                             found = true;
                         }
@@ -1425,34 +1424,6 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 }
                 return super.visitIdentifier(identifier, p);
             }
-
-            override async visitMethodInvocation(methodInvocation: J.MethodInvocation, p: void): Promise<J | undefined> {
-                if (expectedDeclaringType && methodInvocation.methodType && methodInvocation.methodType.name === targetName &&
-                    matchesModule(Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType))) {
-                    found = true;
-                }
-                return super.visitMethodInvocation(methodInvocation, p);
-            }
-
-            override async visitFunctionCall(functionCall: JS.FunctionCall, p: void): Promise<J | undefined> {
-                if (expectedDeclaringType && functionCall.methodType && functionCall.methodType.name === targetName &&
-                    matchesModule(Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType))) {
-                    found = true;
-                }
-                return super.visitFunctionCall(functionCall, p);
-            }
-
-            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: void): Promise<J | undefined> {
-                const type = fieldAccess.type;
-                if (type && Type.isMethod(type)) {
-                    const methodType = type as Type.Method;
-                    if (expectedDeclaringType && methodType.name === targetName &&
-                        matchesModule(Type.FullyQualified.getFullyQualifiedName(methodType.declaringType))) {
-                        found = true;
-                    }
-                }
-                return super.visitFieldAccess(fieldAccess, p);
-            }
         };
 
         await collector.visit(compilationUnit, undefined);

package/src/javascript/format/format.ts

@@ -1121,7 +1121,7 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
             } else if (parent?.kind === J.Kind.Block && grandparent?.kind !== J.Kind.NewClass && grandparent?.kind !== JS.Kind.TypeLiteral ||
                       (parent?.kind === JS.Kind.CompilationUnit && (parent! as JS.CompilationUnit).statements[0].element.id != draft.id) ||
                       (parent?.kind === J.Kind.Case && this.isInsideCaseStatements(parent as J.Case, draft))) {
-                if (draft.kind != J.Kind.Case) {
+                if (draft.kind != J.Kind.Case && !this.opensCaseBody(parent, draft)) {
                     this.ensurePrefixHasNewLine(draft);
                 }
             }
@@ -1151,6 +1151,12 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
      * Check if a statement is inside a Case's statements container or body,
      * not inside the caseLabels container.
      */
+    /** A block that opens a case's statements stays on the line of its label, as in `case X: {`. */
+    private opensCaseBody(parent: J | undefined, statement: J): boolean {
+        return parent?.kind === J.Kind.Case && statement.kind === J.Kind.Block &&
+            (parent as J.Case).statements.elements[0]?.element.id === statement.id;
+    }
+
     private isInsideCaseStatements(caseNode: J.Case, statement: J): boolean {
         // Check if statement is in the statements container
         if (caseNode.statements.elements.some(s => s.element.id === statement.id)) {

package/src/javascript/parser-utils.ts

@@ -17,7 +17,7 @@ import * as ts from "typescript";
 import {Expression, J, Statement} from "../java";
 import {JS} from "./tree";
 
-const is_statements: string[] = [
+const is_statements = new Set<string>([
     J.Kind.Assert,
     J.Kind.Assignment,
     J.Kind.AssignmentOperation,
@@ -55,7 +55,6 @@ const is_statements: string[] = [
     JS.Kind.ArrowFunction,
     JS.Kind.BindingElement,
     JS.Kind.Delete,
-    JS.Kind.Export,
     JS.Kind.ExportAssignment,
     JS.Kind.ExportDeclaration,
     JS.Kind.ForInLoop,
@@ -70,6 +69,8 @@ const is_statements: string[] = [
     JS.Kind.NamespaceDeclaration,
     JS.Kind.PropertyAssignment,
     JS.Kind.ScopedVariableDeclarations,
+    JS.Kind.Shebang,
+    JS.Kind.Spread,
     JS.Kind.TaggedTemplateExpression,
     JS.Kind.TemplateExpression,
     JS.Kind.TypeDeclaration,
@@ -77,9 +78,9 @@ const is_statements: string[] = [
     JS.Kind.WithStatement,
     JS.Kind.ExpressionStatement,
     JS.Kind.StatementExpression
-]
+])
 
-const is_expressions: string[] = [
+const is_expressions = new Set<string>([
     J.Kind.AnnotatedType,
     J.Kind.Annotation,
     J.Kind.ArrayAccess,
@@ -88,6 +89,7 @@ const is_expressions: string[] = [
     J.Kind.AssignmentOperation,
     J.Kind.Binary,
     J.Kind.ControlParentheses,
+    J.Kind.DeconstructionPattern,
     J.Kind.Empty,
     J.Kind.Erroneous,
     J.Kind.FieldAccess,
@@ -114,18 +116,23 @@ const is_expressions: string[] = [
     JS.Kind.Alias,
     JS.Kind.ArrayBindingPattern,
     JS.Kind.ArrowFunction,
+    JS.Kind.As,
     JS.Kind.Await,
     JS.Kind.BindingElement,
+    JS.Kind.ComputedPropertyName,
     JS.Kind.ConditionalType,
     JS.Kind.Delete,
     JS.Kind.ExportSpecifier,
     JS.Kind.ExpressionWithTypeArguments,
+    JS.Kind.FunctionCall,
     JS.Kind.FunctionType,
     JS.Kind.ImportType,
     JS.Kind.IndexedAccessType,
     JS.Kind.IndexedAccessTypeIndexType,
     JS.Kind.InferType,
     JS.Kind.Intersection,
+    JS.Kind.JsxEmbeddedExpression,
+    JS.Kind.JsxTag,
     JS.Kind.AssignmentOperation,
     JS.Kind.Binary,
     JS.Kind.ImportSpecifier,
@@ -135,6 +142,7 @@ const is_expressions: string[] = [
     JS.Kind.NamedImports,
     JS.Kind.ObjectBindingPattern,
     JS.Kind.SatisfiesExpression,
+    JS.Kind.Spread,
     JS.Kind.TaggedTemplateExpression,
     JS.Kind.TemplateExpression,
     JS.Kind.Tuple,
@@ -149,14 +157,14 @@ const is_expressions: string[] = [
     JS.Kind.Void,
     JS.Kind.ExpressionStatement,
     JS.Kind.StatementExpression
-]
+])
 
 export function isStatement(statement: J):  statement is Statement {
-    return is_statements.includes(statement.kind);
+    return is_statements.has(statement.kind);
 }
 
 export function isExpression(expression: J):  expression is Expression {
-    return is_expressions.includes(expression.kind);
+    return is_expressions.has(expression.kind);
 }
 
 export function getNextSibling(node: ts.Node): ts.Node | undefined {

package/src/javascript/scope.ts

@@ -1075,6 +1075,15 @@ export function resolve(cursor: Cursor, identifier: J.Identifier): J | undefined
     return reading && (bindingFrame(scopes, identifier.simpleName, reading)?.node as J | undefined);
 }
 
+/**
+ * Whether the identifier reads a name nothing in the file binds where it stands, a global or nothing
+ * at all. An identifier that names rather than reads is not free. The cursor is as {@link resolve} takes it.
+ */
+export function isFree(cursor: Cursor, identifier: J.Identifier): boolean {
+    const [scopes, reading] = position(pathTo(cursor, identifier), identifier);
+    return reading !== undefined && bindingFrame(scopes, identifier.simpleName, reading) === undefined;
+}
+
 /**
  * Whether the identifier is assigned to where it stands. An assignment's target, plain or compound,
  * is, and so are the operand of `++` or `--`, the head of a for-in or for-of declaring nothing, and

package/src/javascript/templating/precedence.ts

@@ -305,7 +305,7 @@ function slotConstraints(parent: J, childId: string): SlotConstraints | undefine
         case J.Kind.ClassDeclaration:
             // `class A extends B {}` takes a LeftHandSideExpression
             return (parent as J.ClassDeclaration).extends?.element?.id === childId ?
-                {precedence: Precedence.Call} : undefined;
+                {precedence: Precedence.Call, typeTree: true} : undefined;
 
         case JS.Kind.ExpressionStatement:
             return (parent as JS.ExpressionStatement).expression?.id === childId ?