Use a single list of internal commands

Author: rhuanjl

lib/Parser/InternalCommands.h

@@ -0,0 +1,13 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+
+// This file is designed to be included repeatedly to provide a list of internal commands
+// The Command macro should be defined each time before inclusion
+
+// command name, expected parameters
+Command(Conv_Num, 1)
+Command(Conv_Obj, 1)
+
+#undef Command

lib/Parser/Parse.cpp

@@ -2646,17 +2646,18 @@ ParseNodePtr Parser::ParseInternalCommand()
 
     // find the command type
     InternalCommandType type;
+    uint32 expectedParams = 0;
     IdentPtr id = m_token.GetIdentifier(GetHashTbl());
 
-    if (id == internalCommandPids.Conv_Num)
-    {
-        type = InternalCommandType::Conv_Num;
-    }
-    else if (id == internalCommandPids.Conv_Obj)
-    {
-        type = InternalCommandType::Conv_Obj;
-    }
-    else
+    #define Command(name, params) \
+        if (id == internalCommandPids.##name) \
+        { \
+            type = InternalCommandType::##name; \
+            expectedParams = params; \
+        } \
+        else
+
+    #include "InternalCommands.h"
     {
         Error(ERRTokenAfter, m_token.GetIdentifier(GetHashTbl())->Psz(), _u("@@"));
     }
@@ -2670,7 +2671,13 @@ ParseNodePtr Parser::ParseInternalCommand()
 
     for (;;)
     {
-        currentParam = ParseExpr<buildAST>(0);
+        currentParam = ParseExpr<buildAST>(koplCma);
+        if (expectedParams-- == 0)
+        {
+            // throw during parse phase if internal command has too many parameters
+            // as the excess would be ignored upon execution
+            Error(ERRsyntax);
+        }
         if (buildAST)
         {
             AddToNodeListEscapedUse(&params, &lastParam, currentParam);
@@ -2691,6 +2698,13 @@ ParseNodePtr Parser::ParseInternalCommand()
         }
     }
 
+    if (expectedParams != 0)
+    {
+        // throw during parse phase if internal command has too few parameters
+        // as could produce undefined behaviour if executed
+        Error(ERRsyntax);
+    }
+
     ParseNodePtr command = nullptr;
     if (buildAST)
     {
@@ -11863,8 +11877,10 @@ void Parser::InitPids()
 #ifdef ENABLE_TEST_HOOKS
 void Parser::InitInternalCommandPids()
 {
-    internalCommandPids.Conv_Num = this->GetHashTbl()->PidHashNameLen(_u("Conv_Num"), sizeof("Conv_Num") - 1);
-    internalCommandPids.Conv_Obj = this->GetHashTbl()->PidHashNameLen(_u("Conv_Obj"), sizeof("Conv_Obj") - 1);
+    #define Command(name, params) \
+        internalCommandPids.##name = this->GetHashTbl()->PidHashNameLen(_u(#name), sizeof(#name) - 1);
+
+    #include "InternalCommands.h"
 }
 #endif
 

lib/Parser/Parse.h

@@ -511,8 +511,10 @@ class Parser
 #ifdef ENABLE_TEST_HOOKS
     struct InternalCommandPids
     {
-        IdentPtr Conv_Num;
-        IdentPtr Conv_Obj;
+        #define Command(name, params) \
+            IdentPtr name;
+
+        #include "InternalCommands.h"
     };
     InternalCommandPids internalCommandPids;
 #endif

lib/Parser/ptree.h

@@ -446,8 +446,10 @@ class ParseNodeObjLit : public ParseNodeUni
 
 typedef enum InternalCommandType
 {
-    Conv_Num,
-    Conv_Obj
+    #define Command(name, params) \
+        name, //params
+
+    #include "InternalCommands.h"
 } InternalCommandType;
 
 class ParseNodeInternalCommand : public ParseNode
@@ -458,6 +460,8 @@ class ParseNodeInternalCommand : public ParseNode
 
     InternalCommandType commandType;
     ParseNodePtr params;
+
+    DISABLE_SELF_CAST(ParseNodeInternalCommand);
 };
 #endif
 

lib/Runtime/ByteCode/ByteCodeEmitter.cpp

@@ -12301,22 +12301,43 @@ void Emit(ParseNode* pnode, ByteCodeGenerator* byteCodeGenerator, FuncInfo* func
         byteCodeGenerator->StartStatement(pnode);
         funcInfo->AcquireLoc(pnode);
         ParseNodeInternalCommand* command = pnode->AsParseNodeInternalCommand();
-        ParseNode* params = command->params;
-        //ParseNode* param1 = params->AsParseNodeBin()->pnode1;
-        Emit(params, byteCodeGenerator, funcInfo, false);
+
+        Js::OpCode opcode = Js::OpCode::Nop;
+        uint32 expectedParams = 0;
+
+        #define Command(name, params) \
+            case InternalCommandType::##name: \
+                opcode = Js::OpCode::##name; \
+                expectedParams = params; \
+                break;
 
         switch (command->commandType)
         {
-            case InternalCommandType::Conv_Num:
-                byteCodeGenerator->Writer()->Reg2(Js::OpCode::Conv_Num, pnode->location, params->location);
+            #include "InternalCommands.h"
+            default:
+                AssertOrFailFast(0);
+        }
+
+        ParseNode* params = command->params;
+        switch (expectedParams)
+        {
+            case 1:
+                Emit(params, byteCodeGenerator, funcInfo, false);
+                byteCodeGenerator->Writer()->Reg2(opcode, pnode->location, params->location);
                 break;
-            case InternalCommandType::Conv_Obj:
-                byteCodeGenerator->Writer()->Reg2(Js::OpCode::Conv_Obj, pnode->location, params->location);
+            case 2:
+            {
+                ParseNode* param1 = params->AsParseNodeBin()->pnode1;
+                ParseNode* param2 = params->AsParseNodeBin()->pnode2;
+                Emit(param1, byteCodeGenerator, funcInfo, false);
+                Emit(param2, byteCodeGenerator, funcInfo, false);
+                byteCodeGenerator->Writer()->Reg3(opcode, pnode->location, param1->location, param2->location);
                 break;
-
+            }
             default:
-                AssertOrFailFast(0);
+                AssertOrFailFast(0); //currently only support Internal Commands with 1 or 2 parameters
         }
+
         funcInfo->ReleaseLoc(params);
         byteCodeGenerator->EndStatement(pnode);
         break;

lib/Runtime/Library/JsBuiltIn/JsBuiltIn.js

@@ -396,8 +396,7 @@
         // this is FlattenIntoArray from the flat/flatMap proposal BUT with:
         // depth = 1 and the presence of a mapperFunction guaranteed
         // both these conditions are always met when this is called from flatMap
-        // Additionally this is slightly refactored rather than taking a thisArg
-        // the calling function binds the thisArg if it's required
+
         //1. Let targetIndex be start.
         let targetIndex = start;
         //2. Let sourceIndex be 0.