blockly 7.20211209.2 → 8.0.0

package/generators/php/lists.js

@@ -44,11 +44,15 @@ PHP['lists_create_with'] = function(block) {
 
 PHP['lists_repeat'] = function(block) {
   // Create a list with one element repeated.
-  const functionName = PHP.provideFunction_('lists_repeat', [
-    'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($value, $count) {',
-    '  $array = array();', '  for ($index = 0; $index < $count; $index++) {',
-    '    $array[] = $value;', '  }', '  return $array;', '}'
-  ]);
+  const functionName = PHP.provideFunction_('lists_repeat', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($value, $count) {
+  $array = array();
+  for ($index = 0; $index < $count; $index++) {
+    $array[] = $value;
+  }
+  return $array;
+}
+`);
   const element = PHP.valueToCode(block, 'ITEM', PHP.ORDER_NONE) || 'null';
   const repeatCount = PHP.valueToCode(block, 'NUM', PHP.ORDER_NONE) || '0';
   const code = functionName + '(' + element + ', ' + repeatCount + ')';
@@ -57,12 +61,16 @@ PHP['lists_repeat'] = function(block) {
 
 PHP['lists_length'] = function(block) {
   // String or array length.
-  const functionName = PHP.provideFunction_('length', [
-    'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($value) {',
-    '  if (is_string($value)) {', '    return strlen($value);', '  } else {',
-    '    return count($value);', '  }', '}'
-  ]);
-  const list = PHP.valueToCode(block, 'VALUE', PHP.ORDER_NONE) || '\'\'';
+  const functionName = PHP.provideFunction_('length', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($value) {
+  if (is_string($value)) {
+    return strlen($value);
+  } else {
+    return count($value);
+  }
+}
+`);
+  const list = PHP.valueToCode(block, 'VALUE', PHP.ORDER_NONE) || "''";
   return [functionName + '(' + list + ')', PHP.ORDER_FUNCTION_CALL];
 };
 
@@ -75,7 +83,7 @@ PHP['lists_isEmpty'] = function(block) {
 
 PHP['lists_indexOf'] = function(block) {
   // Find an item in the list.
-  const argument0 = PHP.valueToCode(block, 'FIND', PHP.ORDER_NONE) || '\'\'';
+  const argument0 = PHP.valueToCode(block, 'FIND', PHP.ORDER_NONE) || "''";
   const argument1 = PHP.valueToCode(block, 'VALUE', PHP.ORDER_MEMBER) || '[]';
   let errorIndex = ' -1';
   let indexAdjustment = '';
@@ -86,23 +94,25 @@ PHP['lists_indexOf'] = function(block) {
   let functionName;
   if (block.getFieldValue('END') === 'FIRST') {
     // indexOf
-    functionName = PHP.provideFunction_('indexOf', [
-      'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($haystack, $needle) {',
-      '  for ($index = 0; $index < count($haystack); $index++) {',
-      '    if ($haystack[$index] == $needle) return $index' + indexAdjustment +
-          ';',
-      '  }', '  return ' + errorIndex + ';', '}'
-    ]);
+    functionName = PHP.provideFunction_('indexOf', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($haystack, $needle) {
+  for ($index = 0; $index < count($haystack); $index++) {
+    if ($haystack[$index] == $needle) return $index${indexAdjustment};
+  }
+  return ${errorIndex};
+}
+`);
   } else {
     // lastIndexOf
-    functionName = PHP.provideFunction_('lastIndexOf', [
-      'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($haystack, $needle) {',
-      '  $last = ' + errorIndex + ';',
-      '  for ($index = 0; $index < count($haystack); $index++) {',
-      '    if ($haystack[$index] == $needle) $last = $index' + indexAdjustment +
-          ';',
-      '  }', '  return $last;', '}'
-    ]);
+    functionName = PHP.provideFunction_('lastIndexOf', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($haystack, $needle) {
+  $last = ${errorIndex};
+  for ($index = 0; $index < count($haystack); $index++) {
+    if ($haystack[$index] == $needle) $last = $index${indexAdjustment};
+  }
+  return $last;
+}
+`);
   }
 
   const code = functionName + '(' + argument1 + ', ' + argument0 + ')';
@@ -191,26 +201,30 @@ PHP['lists_getIndex'] = function(block) {
     case 'RANDOM': {
       const list = PHP.valueToCode(block, 'VALUE', PHP.ORDER_NONE) || 'array()';
       if (mode === 'GET') {
-        const functionName = PHP.provideFunction_('lists_get_random_item', [
-          'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($list) {',
-          '  return $list[rand(0,count($list)-1)];', '}'
-        ]);
+        const functionName = PHP.provideFunction_('lists_get_random_item', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($list) {
+  return $list[rand(0,count($list)-1)];
+}
+`);
         const code = functionName + '(' + list + ')';
         return [code, PHP.ORDER_FUNCTION_CALL];
       } else if (mode === 'GET_REMOVE') {
         const functionName =
-            PHP.provideFunction_('lists_get_remove_random_item', [
-              'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '(&$list) {',
-              '  $x = rand(0,count($list)-1);', '  unset($list[$x]);',
-              '  return array_values($list);', '}'
-            ]);
+            PHP.provideFunction_('lists_get_remove_random_item', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}(&$list) {
+  $x = rand(0,count($list)-1);
+  unset($list[$x]);
+  return array_values($list);
+}
+`);
         const code = functionName + '(' + list + ')';
         return [code, PHP.ORDER_FUNCTION_CALL];
       } else if (mode === 'REMOVE') {
-        const functionName = PHP.provideFunction_('lists_remove_random_item', [
-          'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '(&$list) {',
-          '  unset($list[rand(0,count($list)-1)]);', '}'
-        ]);
+        const functionName = PHP.provideFunction_('lists_remove_random_item', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}(&$list) {
+  unset($list[rand(0,count($list)-1)]);
+}
+`);
         return functionName + '(' + list + ');\n';
       }
       break;
@@ -252,10 +266,11 @@ PHP['lists_setIndex'] = function(block) {
     case 'LAST': {
       const list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || 'array()';
       if (mode === 'SET') {
-        const functionName = PHP.provideFunction_('lists_set_last_item', [
-          'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '(&$list, $value) {',
-          '  $list[count($list) - 1] = $value;', '}'
-        ]);
+        const functionName = PHP.provideFunction_('lists_set_last_item', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}(&$list, $value) {
+  $list[count($list) - 1] = $value;
+}
+`);
         return functionName + '(' + list + ', ' + value + ');\n';
       } else if (mode === 'INSERT') {
         return 'array_push(' + list + ', ' + value + ');\n';
@@ -279,18 +294,18 @@ PHP['lists_setIndex'] = function(block) {
       const list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || 'array()';
       const at = PHP.getAdjusted(block, 'AT', 1);
       if (mode === 'SET') {
-        const functionName = PHP.provideFunction_('lists_set_from_end', [
-          'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ +
-              '(&$list, $at, $value) {',
-          '  $list[count($list) - $at] = $value;', '}'
-        ]);
+        const functionName = PHP.provideFunction_('lists_set_from_end', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}(&$list, $at, $value) {
+  $list[count($list) - $at] = $value;
+}
+`);
         return functionName + '(' + list + ', ' + at + ', ' + value + ');\n';
       } else if (mode === 'INSERT') {
-        const functionName = PHP.provideFunction_('lists_insert_from_end', [
-          'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ +
-              '(&$list, $at, $value) {',
-          '  return array_splice($list, count($list) - $at, 0, $value);', '}'
-        ]);
+        const functionName = PHP.provideFunction_('lists_insert_from_end', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}(&$list, $at, $value) {
+  return array_splice($list, count($list) - $at, 0, $value);
+}
+`);
         return functionName + '(' + list + ', ' + at + ', ' + value + ');\n';
       }
       break;
@@ -382,29 +397,28 @@ PHP['lists_getSublist'] = function(block) {
   } else {
     const at1 = PHP.getAdjusted(block, 'AT1');
     const at2 = PHP.getAdjusted(block, 'AT2');
-    const functionName = PHP.provideFunction_('lists_get_sublist', [
-      'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ +
-          '($list, $where1, $at1, $where2, $at2) {',
-      '  if ($where1 == \'FROM_END\') {',
-      '    $at1 = count($list) - 1 - $at1;',
-      '  } else if ($where1 == \'FIRST\') {',
-      '    $at1 = 0;',
-      '  } else if ($where1 != \'FROM_START\') {',
-      '    throw new Exception(\'Unhandled option (lists_get_sublist).\');',
-      '  }',
-      '  $length = 0;',
-      '  if ($where2 == \'FROM_START\') {',
-      '    $length = $at2 - $at1 + 1;',
-      '  } else if ($where2 == \'FROM_END\') {',
-      '    $length = count($list) - $at1 - $at2;',
-      '  } else if ($where2 == \'LAST\') {',
-      '    $length = count($list) - $at1;',
-      '  } else {',
-      '    throw new Exception(\'Unhandled option (lists_get_sublist).\');',
-      '  }',
-      '  return array_slice($list, $at1, $length);',
-      '}'
-    ]);
+    const functionName = PHP.provideFunction_('lists_get_sublist', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($list, $where1, $at1, $where2, $at2) {
+  if ($where1 == 'FROM_END') {
+    $at1 = count($list) - 1 - $at1;
+  } else if ($where1 == 'FIRST') {
+    $at1 = 0;
+  } else if ($where1 != 'FROM_START') {
+    throw new Exception('Unhandled option (lists_get_sublist).');
+  }
+  $length = 0;
+  if ($where2 == 'FROM_START') {
+    $length = $at2 - $at1 + 1;
+  } else if ($where2 == 'FROM_END') {
+    $length = count($list) - $at1 - $at2;
+  } else if ($where2 == 'LAST') {
+    $length = count($list) - $at1;
+  } else {
+    throw new Exception('Unhandled option (lists_get_sublist).');
+  }
+  return array_slice($list, $at1, $length);
+}
+`);
     code = functionName + '(' + list + ', \'' + where1 + '\', ' + at1 + ', \'' +
         where2 + '\', ' + at2 + ')';
   }
@@ -416,16 +430,22 @@ PHP['lists_sort'] = function(block) {
   const listCode = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || 'array()';
   const direction = block.getFieldValue('DIRECTION') === '1' ? 1 : -1;
   const type = block.getFieldValue('TYPE');
-  const functionName = PHP.provideFunction_('lists_sort', [
-    'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ +
-        '($list, $type, $direction) {',
-    '  $sortCmpFuncs = array(', '    "NUMERIC" => "strnatcasecmp",',
-    '    "TEXT" => "strcmp",', '    "IGNORE_CASE" => "strcasecmp"', '  );',
-    '  $sortCmp = $sortCmpFuncs[$type];',
-    '  $list2 = $list;',  // Clone list.
-    '  usort($list2, $sortCmp);', '  if ($direction == -1) {',
-    '    $list2 = array_reverse($list2);', '  }', '  return $list2;', '}'
-  ]);
+  const functionName = PHP.provideFunction_('lists_sort', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($list, $type, $direction) {
+  $sortCmpFuncs = array(
+    'NUMERIC' => 'strnatcasecmp',
+    'TEXT' => 'strcmp',
+    'IGNORE_CASE' => 'strcasecmp'
+  );
+  $sortCmp = $sortCmpFuncs[$type];
+  $list2 = $list;
+  usort($list2, $sortCmp);
+  if ($direction == -1) {
+    $list2 = array_reverse($list2);
+  }
+  return $list2;
+}
+`);
   const sortCode =
       functionName + '(' + listCode + ', "' + type + '", ' + direction + ')';
   return [sortCode, PHP.ORDER_FUNCTION_CALL];
@@ -434,12 +454,12 @@ PHP['lists_sort'] = function(block) {
 PHP['lists_split'] = function(block) {
   // Block for splitting text into a list, or joining a list into text.
   let value_input = PHP.valueToCode(block, 'INPUT', PHP.ORDER_NONE);
-  const value_delim = PHP.valueToCode(block, 'DELIM', PHP.ORDER_NONE) || '\'\'';
+  const value_delim = PHP.valueToCode(block, 'DELIM', PHP.ORDER_NONE) || "''";
   const mode = block.getFieldValue('MODE');
   let functionName;
   if (mode === 'SPLIT') {
     if (!value_input) {
-      value_input = '\'\'';
+      value_input = "''";
     }
     functionName = 'explode';
   } else if (mode === 'JOIN') {

package/generators/php/math.js

@@ -34,7 +34,7 @@ PHP['math_arithmetic'] = function(block) {
     'MINUS': [' - ', PHP.ORDER_SUBTRACTION],
     'MULTIPLY': [' * ', PHP.ORDER_MULTIPLICATION],
     'DIVIDE': [' / ', PHP.ORDER_DIVISION],
-    'POWER': [' ** ', PHP.ORDER_POWER]
+    'POWER': [' ** ', PHP.ORDER_POWER],
   };
   const tuple = OPERATORS[block.getFieldValue('OP')];
   const operator = tuple[0];
@@ -134,7 +134,7 @@ PHP['math_constant'] = function(block) {
     'GOLDEN_RATIO': ['(1 + sqrt(5)) / 2', PHP.ORDER_DIVISION],
     'SQRT2': ['M_SQRT2', PHP.ORDER_ATOMIC],
     'SQRT1_2': ['M_SQRT1_2', PHP.ORDER_ATOMIC],
-    'INFINITY': ['INF', PHP.ORDER_ATOMIC]
+    'INFINITY': ['INF', PHP.ORDER_ATOMIC],
   };
   return CONSTANTS[block.getFieldValue('CONSTANT')];
 };
@@ -142,53 +142,55 @@ PHP['math_constant'] = function(block) {
 PHP['math_number_property'] = function(block) {
   // Check if a number is even, odd, prime, whole, positive, or negative
   // or if it is divisible by certain number. Returns true or false.
-  const number_to_check =
-      PHP.valueToCode(block, 'NUMBER_TO_CHECK', PHP.ORDER_MODULUS) || '0';
-  const dropdown_property = block.getFieldValue('PROPERTY');
+  const PROPERTIES = {
+    'EVEN': ['', ' % 2 == 0', PHP.ORDER_MODULUS, PHP.ORDER_EQUALITY],
+    'ODD': ['', ' % 2 == 1', PHP.ORDER_MODULUS, PHP.ORDER_EQUALITY],
+    'WHOLE': ['is_int(', ')', PHP.ORDER_NONE, PHP.ORDER_FUNCTION_CALL],
+    'POSITIVE': ['', ' > 0', PHP.ORDER_RELATIONAL, PHP.ORDER_RELATIONAL],
+    'NEGATIVE': ['', ' < 0', PHP.ORDER_RELATIONAL, PHP.ORDER_RELATIONAL],
+    'DIVISIBLE_BY': [null, null, PHP.ORDER_MODULUS, PHP.ORDER_EQUALITY],
+    'PRIME': [null, null, PHP.ORDER_NONE, PHP.ORDER_FUNCTION_CALL],
+  };
+  const dropdownProperty = block.getFieldValue('PROPERTY');
+  const [prefix, suffix, inputOrder, outputOrder] = PROPERTIES[dropdownProperty];
+  const numberToCheck = PHP.valueToCode(block, 'NUMBER_TO_CHECK',
+      inputOrder) || '0';
   let code;
-  if (dropdown_property === 'PRIME') {
+  if (dropdownProperty === 'PRIME') {
     // Prime is a special case as it is not a one-liner test.
-    const functionName = PHP.provideFunction_('math_isPrime', [
-      'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($n) {',
-      '  // https://en.wikipedia.org/wiki/Primality_test#Naive_methods',
-      '  if ($n == 2 || $n == 3) {', '    return true;', '  }',
-      '  // False if n is NaN, negative, is 1, or not whole.',
-      '  // And false if n is divisible by 2 or 3.',
-      '  if (!is_numeric($n) || $n <= 1 || $n % 1 != 0 || $n % 2 == 0 ||' +
-          ' $n % 3 == 0) {',
-      '    return false;', '  }',
-      '  // Check all the numbers of form 6k +/- 1, up to sqrt(n).',
-      '  for ($x = 6; $x <= sqrt($n) + 1; $x += 6) {',
-      '    if ($n % ($x - 1) == 0 || $n % ($x + 1) == 0) {',
-      '      return false;', '    }', '  }', '  return true;', '}'
-    ]);
-    code = functionName + '(' + number_to_check + ')';
-    return [code, PHP.ORDER_FUNCTION_CALL];
+    const functionName = PHP.provideFunction_('math_isPrime', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($n) {
+  // https://en.wikipedia.org/wiki/Primality_test#Naive_methods
+  if ($n == 2 || $n == 3) {
+    return true;
   }
-  switch (dropdown_property) {
-    case 'EVEN':
-      code = number_to_check + ' % 2 == 0';
-      break;
-    case 'ODD':
-      code = number_to_check + ' % 2 == 1';
-      break;
-    case 'WHOLE':
-      code = 'is_int(' + number_to_check + ')';
-      break;
-    case 'POSITIVE':
-      code = number_to_check + ' > 0';
-      break;
-    case 'NEGATIVE':
-      code = number_to_check + ' < 0';
-      break;
-    case 'DIVISIBLE_BY': {
-      const divisor =
-          PHP.valueToCode(block, 'DIVISOR', PHP.ORDER_MODULUS) || '0';
-      code = number_to_check + ' % ' + divisor + ' == 0';
-      break;
+  // False if n is NaN, negative, is 1, or not whole.
+  // And false if n is divisible by 2 or 3.
+  if (!is_numeric($n) || $n <= 1 || $n % 1 != 0 || $n % 2 == 0 || $n % 3 == 0) {
+    return false;
+  }
+  // Check all the numbers of form 6k +/- 1, up to sqrt(n).
+  for ($x = 6; $x <= sqrt($n) + 1; $x += 6) {
+    if ($n % ($x - 1) == 0 || $n % ($x + 1) == 0) {
+      return false;
     }
   }
-  return [code, PHP.ORDER_EQUALITY];
+  return true;
+}
+`);
+    code = functionName + '(' + numberToCheck + ')';
+  } else if (dropdownProperty === 'DIVISIBLE_BY') {
+    const divisor = PHP.valueToCode(block, 'DIVISOR',
+        PHP.ORDER_MODULUS) || '0';
+    if (divisor === '0') {
+      return ['false', PHP.ORDER_ATOMIC];
+
+    }
+    code = numberToCheck + ' % ' + divisor + ' == 0';
+  } else {
+    code = prefix + numberToCheck + suffix;
+  }
+  return [code, outputOrder];
 };
 
 PHP['math_change'] = function(block) {
@@ -226,23 +228,23 @@ PHP['math_on_list'] = function(block) {
       code = 'max(' + list + ')';
       break;
     case 'AVERAGE': {
-      const functionName = PHP.provideFunction_('math_mean', [
-        'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($myList) {',
-        '  return array_sum($myList) / count($myList);', '}'
-      ]);
+      const functionName = PHP.provideFunction_('math_mean', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($myList) {
+  return array_sum($myList) / count($myList);
+}
+`);
       list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || 'array()';
       code = functionName + '(' + list + ')';
       break;
     }
     case 'MEDIAN': {
-      const functionName = PHP.provideFunction_('math_median', [
-        'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($arr) {',
-        '  sort($arr,SORT_NUMERIC);',
-        '  return (count($arr) % 2) ? $arr[floor(count($arr)/2)] : ',
-        '      ($arr[floor(count($arr)/2)] + $arr[floor(count($arr)/2)' +
-            ' - 1]) / 2;',
-        '}'
-      ]);
+      const functionName = PHP.provideFunction_('math_median', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($arr) {
+  sort($arr,SORT_NUMERIC);
+  return (count($arr) % 2) ? $arr[floor(count($arr) / 2)] :
+      ($arr[floor(count($arr) / 2)] + $arr[floor(count($arr) / 2) - 1]) / 2;
+}
+`);
       list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
@@ -251,36 +253,40 @@ PHP['math_on_list'] = function(block) {
       // As a list of numbers can contain more than one mode,
       // the returned result is provided as an array.
       // Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1].
-      const functionName = PHP.provideFunction_('math_modes', [
-        'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($values) {',
-        '  if (empty($values)) return array();',
-        '  $counts = array_count_values($values);',
-        '  arsort($counts); // Sort counts in descending order',
-        '  $modes = array_keys($counts, current($counts), true);',
-        '  return $modes;', '}'
-      ]);
+      const functionName = PHP.provideFunction_('math_modes', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($values) {
+  if (empty($values)) return array();
+  $counts = array_count_values($values);
+  arsort($counts); // Sort counts in descending order
+  $modes = array_keys($counts, current($counts), true);
+  return $modes;
+}
+`);
       list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
     }
     case 'STD_DEV': {
-      const functionName = PHP.provideFunction_('math_standard_deviation', [
-        'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($numbers) {',
-        '  $n = count($numbers);', '  if (!$n) return null;',
-        '  $mean = array_sum($numbers) / count($numbers);',
-        '  foreach($numbers as $key => $num) $devs[$key] = ' +
-            'pow($num - $mean, 2);',
-        '  return sqrt(array_sum($devs) / (count($devs) - 1));', '}'
-      ]);
+      const functionName = PHP.provideFunction_('math_standard_deviation', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($numbers) {
+  $n = count($numbers);
+  if (!$n) return null;
+  $mean = array_sum($numbers) / count($numbers);
+  foreach($numbers as $key => $num) $devs[$key] = pow($num - $mean, 2);
+  return sqrt(array_sum($devs) / (count($devs) - 1));
+}
+`);
       list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
     }
     case 'RANDOM': {
-      const functionName = PHP.provideFunction_('math_random_list', [
-        'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($list) {',
-        '  $x = rand(0, count($list)-1);', '  return $list[$x];', '}'
-      ]);
+      const functionName = PHP.provideFunction_('math_random_list', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($list) {
+  $x = rand(0, count($list)-1);
+  return $list[$x];
+}
+`);
       list = PHP.valueToCode(block, 'LIST', PHP.ORDER_NONE) || '[]';
       code = functionName + '(' + list + ')';
       break;
@@ -315,11 +321,14 @@ PHP['math_random_int'] = function(block) {
   // Random integer between [X] and [Y].
   const argument0 = PHP.valueToCode(block, 'FROM', PHP.ORDER_NONE) || '0';
   const argument1 = PHP.valueToCode(block, 'TO', PHP.ORDER_NONE) || '0';
-  const functionName = PHP.provideFunction_('math_random_int', [
-    'function ' + PHP.FUNCTION_NAME_PLACEHOLDER_ + '($a, $b) {',
-    '  if ($a > $b) {', '    return rand($b, $a);', '  }',
-    '  return rand($a, $b);', '}'
-  ]);
+  const functionName = PHP.provideFunction_('math_random_int', `
+function ${PHP.FUNCTION_NAME_PLACEHOLDER_}($a, $b) {
+  if ($a > $b) {
+    return rand($b, $a);
+  }
+  return rand($a, $b);
+}
+`);
   const code = functionName + '(' + argument0 + ', ' + argument1 + ')';
   return [code, PHP.ORDER_FUNCTION_CALL];
 };