fix: add directive field to ExpressionStatement

src/convert.ts

@@ -82,14 +82,19 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
 
   /**
    * Converts a TypeScript node into an ESTree node.
-   * @param  {ts.Node} child the child ts.Node
+   * @param {ts.Node} child the child ts.Node
    * @returns {ESTreeNode|null}       the converted ESTree node
    */
   function convertChild(child?: ts.Node): ESTreeNode | null {
     if (!child) {
       return null;
     }
-    return convert({ node: child, parent: node, ast, additionalOptions });
+    return convert({
+      node: child,
+      parent: node,
+      ast,
+      additionalOptions
+    });
   }
 
   /**
@@ -110,6 +115,34 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
     };
   }
 
+  /**
+   * Coverts body ExpressionStatements to directives
+   */
+  function convertBodyExpressionsToDirectives() {
+    if (result.body && nodeUtils.canContainDirective(node)) {
+      const unique: string[] = [];
+
+      // directives has to be unique, if directive is registered twice pick only first one
+      result.body
+        .filter(
+          (child: ESTreeNode) =>
+            child.type === AST_NODE_TYPES.ExpressionStatement &&
+            child.expression &&
+            child.expression.type === AST_NODE_TYPES.Literal &&
+            (child.expression as any).value &&
+            typeof (child.expression as any).value === 'string'
+        )
+        .forEach(
+          (child: { directive: string; expression: { raw: string } }) => {
+            if (!unique.includes((child.expression as any).raw)) {
+              child.directive = child.expression.raw.slice(1, -1);
+              unique.push(child.expression.raw);
+            }
+          }
+        );
+    }
+  }
+
   /**
    * Converts a ts.Node's typeArguments ts.NodeArray to a flow-like typeParameters node
    * @param {ts.NodeArray<any>} typeArguments ts.Node typeArguments
@@ -519,6 +552,8 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
         }
       });
 
+      convertBodyExpressionsToDirectives();
+
       (result as any).range[1] = node.endOfFileToken.end;
       result.loc = nodeUtils.getLocFor(
         node.getStart(ast),
@@ -532,6 +567,8 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
         type: AST_NODE_TYPES.BlockStatement,
         body: node.statements.map(convertChild)
       });
+
+      convertBodyExpressionsToDirectives();
       break;
 
     case SyntaxKind.Identifier:
@@ -774,12 +811,13 @@ export default function convert(config: ConvertConfig): ESTreeNode | null {
 
     // Expressions
 
-    case SyntaxKind.ExpressionStatement:
+    case SyntaxKind.ExpressionStatement: {
       Object.assign(result, {
         type: AST_NODE_TYPES.ExpressionStatement,
         expression: convertChild(node.expression)
       });
       break;
+    }
 
     case SyntaxKind.ThisKeyword:
       Object.assign(result, {

src/node-utils.ts

@@ -142,6 +142,7 @@ export default {
   getLocFor,
   getLoc,
   isToken,
+  canContainDirective,
   isJSXToken,
   getDeclarationKind,
   getTSNodeAccessibility,
@@ -292,6 +293,34 @@ function getLocFor(
   };
 }
 
+/**
+ * Check whatever node can contain directive
+ * @param {ts.Node} node
+ * @returns {boolean} returns true if node can contain directive
+ */
+function canContainDirective(node: ts.Node): boolean {
+  switch (node.kind) {
+    case ts.SyntaxKind.SourceFile:
+    case ts.SyntaxKind.ModuleBlock:
+      return true;
+    case ts.SyntaxKind.Block:
+      switch (node.parent.kind) {
+        case ts.SyntaxKind.Constructor:
+        case ts.SyntaxKind.GetAccessor:
+        case ts.SyntaxKind.SetAccessor:
+        case ts.SyntaxKind.ArrowFunction:
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.FunctionDeclaration:
+        case ts.SyntaxKind.MethodDeclaration:
+          return true;
+        default:
+          return false;
+      }
+    default:
+      return false;
+  }
+}
+
 /**
  * Returns line and column data for the given ts.Node or ts.Token,
  * for the given AST

tests/ast-alignment/fixtures-to-test.ts

@@ -105,7 +105,7 @@ function createFixturePatternConfigFor(
  * An array of FixturePatternConfigs
  */
 let fixturePatternConfigsToTest = [
-  createFixturePatternConfigFor('basics'),
+  createFixturePatternConfigFor('javascript/basics'),
 
   createFixturePatternConfigFor('comments', {
     ignore: [
@@ -123,6 +123,8 @@ let fixturePatternConfigsToTest = [
     ignore: ['**/*']
   }),
 
+  createFixturePatternConfigFor('javascript/directives'),
+
   createFixturePatternConfigFor('javascript/experimentalObjectRestSpread', {
     ignore: [
       /**

tests/ast-alignment/utils.ts

@@ -107,10 +107,6 @@ export function preprocessBabylonAST(ast: any): any {
       key: 'directives',
       predicate: always
     },
-    {
-      key: 'directive',
-      predicate: always
-    },
     {
       key: 'innerComments',
       predicate: always

tests/fixtures/javascript/directives/block.src.js

@@ -0,0 +1,5 @@
+function foo() {
+  "use strict";
+  var a = 1;
+  "use strict";
+}

tests/fixtures/javascript/directives/directive-in-class.src.js

@@ -0,0 +1,19 @@
+"use strict";
+
+class Foo {
+    constructor () {
+        "use strict";
+    }
+
+    get foo () {
+        "use strict";
+    }
+
+    set foo (value) {
+        "use strict";
+    }
+
+    method () {
+        "use strict";
+    }
+}

tests/fixtures/javascript/directives/function-non-strict.src.js

@@ -0,0 +1,4 @@
+function foo () {
+  "use smth"
+  1+1;
+}

tests/fixtures/javascript/directives/non-directive-string.src.js

@@ -0,0 +1,16 @@
+if (true) {
+    "use strict"
+}
+
+switch (true) {
+    case false: {
+        "use strict"
+    }
+    default: {
+        "use strict"
+    }
+}
+
+while (true) {
+    "use strict"
+}

tests/fixtures/javascript/directives/program-order.src.js

@@ -0,0 +1,3 @@
+"use strict";
+"use loose";
+var a;

tests/fixtures/javascript/directives/program.src.js

@@ -0,0 +1,3 @@
+"use strict";
+var a = 1;
+"use strict";

tests/fixtures/javascript/directives/raw.src.js

@@ -0,0 +1 @@
+"use\x20strict";