Implement support for evaluating computed properties.

packages/babel-traverse/src/path/evaluation.ts

@@ -158,20 +158,32 @@ function _evaluate(path: NodePath, state: State): any {
     return evaluateCached(path.get("expression"), state);
   }
 
-  // "foo".length
+  // "foo".length, "foo"[0]
   if (
     path.isMemberExpression() &&
     !path.parentPath.isCallExpression({ callee: path.node })
   ) {
     const property = path.get("property");
     const object = path.get("object");
 
-    if (object.isLiteral() && property.isIdentifier()) {
+    if (object.isLiteral()) {
       // @ts-expect-error todo(flow->ts): instead of typeof - would it be better to check type of ast node?
       const value = object.node.value;
       const type = typeof value;
-      if (type === "number" || type === "string") {
-        return value[property.node.name];
+
+      let key = null;
+      if (path.node.computed) {
+        key = evaluateCached(property, state);
+        if (!state.confident) return;
+      } else if (property.isIdentifier()) {
+        key = property.node.name;
+      }
+      if (
+        (type === "number" || type === "string") &&
+        key != null &&
+        (typeof key === "number" || typeof key === "string")
+      ) {
+        return value[key];
       }
     }
   }

packages/babel-traverse/test/evaluation.js

@@ -114,6 +114,16 @@ describe("evaluation", function () {
         .get("body.0.declarations.0.init")
         .evaluate().value,
     ).toBe(3);
+    expect(
+      getPath("var x = 'hello world'[6]")
+        .get("body.0.declarations.0.init")
+        .evaluate().value,
+    ).toBe("w");
+    expect(
+      getPath("var length = 1; var x = 'abc'[length];")
+        .get("body.1.declarations.0.init")
+        .evaluate().value,
+    ).toBe("b");
     const member_expr = getPath(
       "var x = Math.min(2,Math.max(3,4));var y = Math.random();",
     );