fix(parser): fixed issue with module code not in strict mode in a few…

… cases

package.json

@@ -1,6 +1,6 @@
 {
   "name": "meriyah",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A 100% compliant, self-hosted javascript parser with high focus on both performance and stability",
   "main": "dist/meriyah.umd.js",
   "module": "dist/meriyah.esm.js",

src/errors.ts

@@ -97,6 +97,7 @@ export const enum Errors {
   NewlineAfterThrow,
   StrictWith,
   IllegalReturn,
+  InvalidForLHSBinding,
   InvalidNewTarget,
   InvalidEscapedKeyword,
   MissingPrivateName,
@@ -265,9 +266,10 @@ export const errorMessages: {
   [Errors.NewlineAfterThrow]: 'Illegal newline after throw',
   [Errors.StrictWith]: 'Strict mode code may not include a with statement',
   [Errors.IllegalReturn]: 'Illegal return statement',
+  [Errors.InvalidForLHSBinding]: 'The for-header left hand side binding declaration is not destructible',
   [Errors.InvalidNewTarget]: 'new.target only allowed within functions',
   [Errors.InvalidEscapedKeyword]: 'Keywords must be written literally, without embedded escapes',
-  [Errors.MissingPrivateName]: "'#' not followed by identifier",
+  [Errors.MissingPrivateName]: "''#' not followed by identifier",
   [Errors.InvalidStrictStatic]: '`Static` is a reserved word in strict mode',
   [Errors.FutureReservedWordInStrictModeNotId]:
     'The use of a future reserved word for an identifier is invalid. The identifier name is reserved in strict mode',

src/parser.ts

@@ -197,7 +197,7 @@ export interface Options {
 export function parseSource(source: string, options: Options | void, context: Context): ESTree.Program {
   let sourceFile = '';
   if (options != null) {
-    if (options.module) context |= Context.Module;
+    if (options.module) context |= Context.Module | Context.Strict;
     if (options.next) context |= Context.OptionsNext;
     if (options.loc) context |= Context.OptionsLoc;
     if (options.ranges) context |= Context.OptionsRanges;
@@ -4298,7 +4298,9 @@ export function parseFunctionDeclaration(
 
       // A function behaves as a lexical binding, except in a script scope, or in any function scope.
       const mode =
-        context & Context.TopLevel && (context & Context.Module) === 0 ? BindingType.Variable : BindingType.Let;
+        ((context & Context.InGlobal) === 0 || (context & Context.Module) === 0) && context & Context.TopLevel
+          ? BindingType.Variable
+          : BindingType.Let;
 
       addFunctionName(parser, context, scope, parser.tokenValue, mode, 1);
 

test/parser/lexical/function.ts

@@ -101,7 +101,9 @@ describe('Lexical - Function', () => {
     ['(function() { { function foo() {} function* foo() {} } })()', Context.OptionsLexical],
     ['(function() { { async function foo() {} async function foo() {} } })()', Context.OptionsLexical],
     ['let x; { var x; }', Context.OptionsLexical],
-    ['{ var x; } let x;', Context.OptionsLexical]
+    ['{ var x; } let x;', Context.OptionsLexical],
+    ['"use strict"; function foo(bar, bar){}', Context.OptionsLexical],
+    ['function foo(bar, bar){}', Context.OptionsLexical | Context.Module | Context.Strict]
   ]);
 
   for (const arg of [
@@ -210,6 +212,8 @@ describe('Lexical - Function', () => {
     function* x() { yield 1; }
     { function* x() { yield 2 } }
   })();`,
+    `function a() {}
+function a() {}`,
     `(function() {
     var y;
     async function x() { y = 1; }