@@ -1,16 +1,10 @@
 import type Printer from "../printer.ts";
-import {
-  isCallExpression,
-  isLiteral,
-  isMemberExpression,
-  isNewExpression,
-  isPattern,
-} from "@babel/types";
+import { isLiteral, isMemberExpression, isPattern } from "@babel/types";
 // We inline this package
 // eslint-disable-next-line import/no-extraneous-dependencies
 import * as charCodes from "charcodes";
 import type * as t from "@babel/types";
-import { TokenContext } from "../node/index.ts";
+import { TokenContext, hasPostfixPart } from "../node/index.ts";
 
 export function UnaryExpression(this: Printer, node: t.UnaryExpression) {
   const { operator } = node;
@@ -94,18 +88,20 @@ export function NewExpression(
   node: t.NewExpression,
   parent: t.Node,
 ) {
+  const omitArguments =
+    this.format.minified &&
+    node.arguments.length === 0 &&
+    !node.typeArguments &&
+    (process.env.BABEL_8_BREAKING ||
+      // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8
+      (!node.typeParameters && !node.optional));
+  const wrapInParens = omitArguments && hasPostfixPart(node, parent);
+  if (wrapInParens) this.token("(");
   this.word("new");
   this.space();
   this.print(node.callee);
-  if (
-    this.format.minified &&
-    node.arguments.length === 0 &&
-    // @ts-ignore(Babel 7 vs Babel 8) Removed in Babel 8
-    !node.optional &&
-    !isCallExpression(parent, { callee: node }) &&
-    !isMemberExpression(parent) &&
-    !isNewExpression(parent)
-  ) {
+  if (omitArguments) {
+    if (wrapInParens) this.token(")");
     return;
   }
 
@@ -122,7 +118,8 @@ export function NewExpression(
   if (
     node.arguments.length === 0 &&
     this.tokenMap &&
-    !this.tokenMap.endMatches(node, ")")
+    !this.tokenMap.endMatches(node, ")") &&
+    (!hasPostfixPart(node, parent) || node.extra?.parenthesized)
   ) {
     return;
   }
 
@@ -38,6 +38,15 @@ for (const type of Object.keys(parens) as (keyof typeof parens)[]) {
   }
 }
 
+// Whether the parent prints something right after the node, such as `()` in
+// `node()`, `.x` in `node.x` or `!` in `node!`.
+export function hasPostfixPart(node: t.Node, parent: t.Node | null): boolean {
+  return (
+    parent != null &&
+    parens.hasPostfixPart(node, parent, generatorInfosMap.get(parent.type)![1])
+  );
+}
+
 function newCalleeNeedsParens(node: t.Node): boolean {
   let current: t.Node = node;
   while (true) {
 
@@ -56,7 +56,7 @@ const isClassExtendsClause = (
   );
 };
 
-const hasPostfixPart = (node: t.Node, parent: any, parentId: number) => {
+export const hasPostfixPart = (node: t.Node, parent: any, parentId: number) => {
   switch (parentId) {
     case __node("MemberExpression"):
     case __node("OptionalMemberExpression"):
@@ -354,6 +354,13 @@ export function TSInstantiationExpression(
           : // @ts-ignore(Babel 7 vs Babel 8) Babel 7 AST
             parent.typeParameters) != null
       );
+    case __node("MemberExpression"):
+    case __node("OptionalMemberExpression"):
+      // `a<b>.c` is invalid, and `a<b>[0]` is parsed as a comparison
+      return parent.object === node;
+    case __node("TSNonNullExpression"):
+      // `a<b>!` is invalid
+      return true;
   }
 
   return false;
 
@@ -0,0 +1,5 @@
+(new F)!;
+(new F)!.b;
+(new F)<T>;
+new F<T>();
+new (F<T>).b;
@@ -0,0 +1,3 @@
+{
+  "plugins": ["typescript"]
+}
@@ -0,0 +1 @@
+(new F)!;(new F)!.b;(new F)<T>;new F<T>();new(F<T>).b;
@@ -6,3 +6,15 @@ new new x()();
 new new x()(a);
 new new x(a)();
 new new x(a)(a);
+
+(new F)?.();
+(new F)?.b;
+(new F)?.[b];
+(new F)`x`;
+
+a[new F];
+new G(new F);
+
+new F().x.y;
+new F()[0];
+new (new F)().x;
@@ -0,0 +1,7 @@
+(a<T>).b;
+(a<T>)?.b;
+(a<T>)[0];
+(a<T>)?.[0];
+(a<T>)!;
+new (F<T>).b();
+new (F<T>)!();
@@ -0,0 +1,3 @@
+{
+  "plugins": ["typescript"]
+}
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "plugins": ["typescript"]`
	`3`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+(new F)!;(new F)!.b;(new F)<T>;new F<T>();new(F<T>).b;`