Various fixes

Author: dsherret

deployment/schema.json

@@ -645,6 +645,18 @@
         "description": "Ex. `function<T>()`"
       }]
     },
+    "functionExpression.flatIife": {
+      "description": "Whether to skip indenting the body of a function expression used in an IIFE.",
+      "type": "boolean",
+      "default": false,
+      "oneOf": [{
+        "const": true,
+        "description": "Does not indent the body of the function in `(function() { ... })();`."
+      }, {
+        "const": false,
+        "description": "Indents the body as normal."
+      }]
+    },
     "getAccessor.spaceBeforeParentheses": {
       "description": "Whether to add a space before the parentheses of a get accessor.",
       "type": "boolean",
@@ -973,6 +985,9 @@
     "functionExpression.spaceAfterFunctionKeyword": {
       "$ref": "#/definitions/functionExpression.spaceAfterFunctionKeyword"
     },
+    "functionExpression.flatIife": {
+      "$ref": "#/definitions/functionExpression.flatIife"
+    },
     "getAccessor.spaceBeforeParentheses": {
       "$ref": "#/definitions/getAccessor.spaceBeforeParentheses"
     },

src/configuration/builder.rs

@@ -348,12 +348,12 @@ impl ConfigurationBuilder {
     self.insert("functionExpression.spaceAfterFunctionKeyword", value.into())
   }
 
-  /// Whether to indent the body of a function expression used in an IIFE.
+  /// Whether to skip indenting the body of a function expression used in an IIFE.
   ///
-  /// `true` (default) - Indents the body as normal.
-  /// `false` - Does not indent the body of the function in `(function() { ... })();`.
-  pub fn function_expression_indent_inside_iife(&mut self, value: bool) -> &mut Self {
-    self.insert("functionExpression.indentInsideIife", value.into())
+  /// `true` - Does not indent the body of the function in `(function() { ... })();`.
+  /// `false` (default) - Indents the body as normal.
+  pub fn function_expression_flat_iife(&mut self, value: bool) -> &mut Self {
+    self.insert("functionExpression.flatIife", value.into())
   }
 
   /// Whether to add a space before the parentheses of a get accessor.

src/configuration/resolve_config.rs

@@ -289,7 +289,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     function_declaration_space_before_parentheses: get_value(&mut config, "functionDeclaration.spaceBeforeParentheses", false, &mut diagnostics),
     function_expression_space_before_parentheses: get_value(&mut config, "functionExpression.spaceBeforeParentheses", false, &mut diagnostics),
     function_expression_space_after_function_keyword: get_value(&mut config, "functionExpression.spaceAfterFunctionKeyword", false, &mut diagnostics),
-    function_expression_indent_inside_iife: get_value(&mut config, "functionExpression.indentInsideIife", true, &mut diagnostics),
+    function_expression_flat_iife: get_value(&mut config, "functionExpression.flatIife", false, &mut diagnostics),
     get_accessor_space_before_parentheses: get_value(&mut config, "getAccessor.spaceBeforeParentheses", false, &mut diagnostics),
     if_statement_space_after_if_keyword: get_value(&mut config, "ifStatement.spaceAfterIfKeyword", true, &mut diagnostics),
     import_declaration_space_surrounding_named_imports: get_value(&mut config, "importDeclaration.spaceSurroundingNamedImports", true, &mut diagnostics),

src/configuration/types.rs

@@ -604,8 +604,8 @@ pub struct Configuration {
   pub function_expression_space_before_parentheses: bool,
   #[serde(rename = "functionExpression.spaceAfterFunctionKeyword")]
   pub function_expression_space_after_function_keyword: bool,
-  #[serde(rename = "functionExpression.indentInsideIife")]
-  pub function_expression_indent_inside_iife: bool,
+  #[serde(rename = "functionExpression.flatIife")]
+  pub function_expression_flat_iife: bool,
   #[serde(rename = "getAccessor.spaceBeforeParentheses")]
   pub get_accessor_space_before_parentheses: bool,
   #[serde(rename = "ifStatement.spaceAfterIfKeyword")]

src/generation/generate.rs

@@ -2639,17 +2639,23 @@ fn gen_expr_with_type_args<'a>(node: &TsExprWithTypeArgs<'a>, context: &mut Cont
 }
 
 fn is_iife_fn_expr(node: &FnExpr) -> bool {
-  let parent = node.parent();
-  if parent.kind() == NodeKind::ParenExpr {
-    if let Some(grandparent) = parent.parent() {
-      return grandparent.kind() == NodeKind::CallExpr;
-    }
+  let mut current: Node = node.into();
+  while let Some(parent) = current.parent() {
+    if parent.is::<ParenExpr>() {
+      current = parent;
+      continue;
+    }
+    return match parent {
+      Node::CallExpr(call) => call.callee.range() == current.range(),
+      Node::OptCall(call) => call.callee.range() == current.range(),
+      _ => false,
+    };
   }
   false
 }
 
 fn gen_fn_expr<'a>(node: &FnExpr<'a>, context: &mut Context<'a>) -> PrintItems {
-  if !context.config.function_expression_indent_inside_iife && is_iife_fn_expr(node) {
+  if context.config.function_expression_flat_iife && is_iife_fn_expr(node) {
     context.skip_iife_body_indent = true;
   }
 

…ionExpression_IndentInsideIife_False.txt …ion/FunctionExpression_FlatIife_True.txttests/specs/expressions/FunctionExpression/FunctionExpression_IndentInsideIife_False.txt renamed to tests/specs/expressions/FunctionExpression/FunctionExpression_FlatIife_True.txt tests/specs/expressions/FunctionExpression/FunctionExpression_IndentInsideIife_False.txt renamed to tests/specs/expressions/FunctionExpression/FunctionExpression_FlatIife_True.txt

@@ -1,4 +1,4 @@
-~~ functionExpression.indentInsideIife: false ~~
+~~ functionExpression.flatIife: true ~~
 == should not indent body of IIFE ==
 (function() {
     const a = "foobar";
@@ -92,3 +92,63 @@ return inner();
 
 [expect]
 (function() {})();
+
+== should not indent body of IIFE wrapped in extra parens ==
+((function() {
+    const a = "foobar";
+    return { a };
+}))();
+
+[expect]
+(function() {
+const a = "foobar";
+return { a };
+})();
+
+== should not indent body of optional IIFE ==
+(function() {
+    const a = "foobar";
+    return { a };
+})?.();
+
+[expect]
+(function() {
+const a = "foobar";
+return { a };
+})?.();
+
+== should not indent body of bare-callee IIFE ==
+void function() {
+    const a = "foobar";
+    return { a };
+}();
+
+[expect]
+void function() {
+const a = "foobar";
+return { a };
+}();
+
+== should still indent body of function expression in member call ==
+(function() {
+    const a = "foobar";
+    return { a };
+}).call(null);
+
+[expect]
+(function() {
+    const a = "foobar";
+    return { a };
+}).call(null);
+
+== should still indent body of function expression as call argument ==
+foo((function() {
+    const a = "foobar";
+    return { a };
+}));
+
+[expect]
+foo(function() {
+    const a = "foobar";
+    return { a };
+});