Убийцы оптимизации JS уже не такие страшные

и даже try-catch больше не является проблемой.
…
На данный момент не оптимизируются:

• функции, содержащие выражение try-catch;

Хм...?

Для ноды есть небольшой модуль will-it-optimize. Он позволяет быстро посмотреть, что убивает оптимизацию для текущей версии ноды, а что нет.

'use strict';

function tryCatch() {
  try {
    return null;
  } catch(e) {
    return e;
  }
}
checkOptimizationStatus(tryCatch);

function forOf() {
  var r = 0, a = [1,2,3];
  for(var e of a) r += e;
  return r;
}
checkOptimizationStatus(forOf);

function forIn() {
  var r = 0, a = {1:1, 2:2, 3:3};
  for(var e in a) if(a.hasOwnProperty(e)) r += a[e];
  return r;
}
checkOptimizationStatus(forIn);

function constDecl() {
  const a = 5;
  return a;
}
checkOptimizationStatus(constDecl);

function letDecl() {
  let a = 5;
  return a;
}
checkOptimizationStatus(letDecl);

function argsRest(...args) {
  return args;
}
checkOptimizationStatus(argsRest);

function argumentsRewrite(a) {
  a = a || 5;
  return a;
}
checkOptimizationStatus(argumentsRewrite);

function argumentsLeak1() {
  return arguments;
}
checkOptimizationStatus(argumentsLeak1);

function argumentsLeak2() {
  return Array.prototype.slice.call(arguments);
}
checkOptimizationStatus(argumentsLeak2);

function argumentsLeakToSecondArgOfApply() {
  return Array.prototype.concat.apply([], arguments);
}
checkOptimizationStatus(argumentsLeakToSecondArgOfApply);

function defaultArguments(a, b = 5) {
  return a + b;
}
checkOptimizationStatus(defaultArguments);

function arrayDestruct() {
  const [a, b, c] = [1, 2, 3];
  return a + b + c;
}
checkOptimizationStatus(arrayDestruct);

function objectDestruct() {
  const {a, b, c} = {a: 1, b: 2, c: 3};
  return a + b + c;
}
checkOptimizationStatus(objectDestruct);

function* generatorSimple() {
  yield 1;
  yield 2;
  yield 3;
}
checkOptimizationStatus(generatorSimple);

function* generatorInfinity() {
  var i = 0;
  while(true) yield i++;
}
checkOptimizationStatus(generatorInfinity);

function infinityLoop(n = 10) {
  var a = false;
  while(true) {
    if(a) break;
    if(n-- === 0) a = true;
  }
}
checkOptimizationStatus(infinityLoop);

function containsObjectLiteralWithProto() {
  return {__proto__: String.prototype};
}
checkOptimizationStatus(containsObjectLiteralWithProto);

function containsObjectLiteralWithGetter() {
  return {
    get prop() {
      return 3;
    }
  };
}
checkOptimizationStatus(containsObjectLiteralWithGetter);

function containsObjectLiteralWithSetter() {
  return {
    set prop(val) {
      this.val = val;
    }
  };
}
checkOptimizationStatus(containsObjectLiteralWithSetter);

class ClassStatic {
  static classStaticMethod() {}
}
checkOptimizationStatus(ClassStatic.classStaticMethod);

class ClassConstructor {
  constructor() {}
}
checkOptimizationStatus(ClassConstructor, true);

function checkOptimizationStatus(fn, withNew = false) {
  if(withNew) {
    new fn();
    new fn();
    %OptimizeFunctionOnNextCall(fn);
    new fn();
  } else {
    fn();
    fn();
    %OptimizeFunctionOnNextCall(fn);
    fn();
  }

  switch (%GetOptimizationStatus(fn)) {
    case 1: console.log(fn.name, 'Function is optimized'); break;
    case 2: console.log(fn.name, 'Function is not optimized'); break;
    case 3: console.log(fn.name, 'Function is always optimized'); break;
    case 4: console.log(fn.name, 'Function is never optimized'); break;
    case 6: console.log(fn.name, 'Function is maybe deoptimized'); break;
    case 7: console.log(fn.name, 'Function is optimized by TurboFan'); break;
    default: console.log(fn.name, 'Unknown optimization status'); break;
  }
}

let s = 0;
  for(let i = 0; i < 1000; i++) {
    s += i;
  }
  console.log(s);
// то, что это деоптимизируется можно увидеть и в профайлере без всяких флагов