Remove string switches.

Author: nicolasstucki

src/com/google/javascript/jscomp/CheckConformance.java

@@ -192,18 +192,16 @@ private static void checkRequirementList(AbstractCompiler compiler, Requirement
   }
 
   private static List<String> getRequirementList(Requirement requirement, String field) {
-    switch (field) {
-      case "whitelist":
-        return requirement.getWhitelistList();
-      case "whitelist_regexp":
-        return requirement.getWhitelistRegexpList();
-      case "only_apply_to":
-        return requirement.getOnlyApplyToList();
-      case "only_apply_to_regexp":
-        return requirement.getOnlyApplyToRegexpList();
-      default:
-        throw new AssertionError("Unrecognized field: " + field);
-    }
+    if (field.equals("whitelist"))
+      return requirement.getWhitelistList();
+    else if (field.equals("whitelist_regexp"))
+      return requirement.getWhitelistRegexpList();
+    else if (field.equals("only_apply_to"))
+      return requirement.getOnlyApplyToList();
+    else if (field.equals("only_apply_to_regexp"))
+      return requirement.getOnlyApplyToRegexpList();
+    else
+      throw new AssertionError("Unrecognized field: " + field);
   }
 
   private static Rule initRule(

src/com/google/javascript/jscomp/Compiler.java

@@ -2604,29 +2604,26 @@ Node ensureLibraryInjected(String resourceName, boolean force) {
          node = ast.getFirstChild()) {
       String directive = node.getFirstChild().getString();
       List<String> words = Splitter.on(' ').splitToList(directive);
-      switch (words.get(0)) {
-        case "use":
-          // 'use strict' is ignored (and deleted).
-          break;
-        case "require":
-          // 'require lib1 lib2'; pulls in the named libraries before this one.
-          for (String dependency : words.subList(1, words.size())) {
-            ensureLibraryInjected(dependency, force);
-          }
-          break;
-        case "declare":
-          // 'declare name1 name2'; adds the names to the externs (with no type information).
-          // Note that we could simply add the entire externs library, but that leads to
-          // potentially-surprising behavior when the externs that are present depend on
-          // whether or not a polyfill is used.
-          for (String extern : words.subList(1, words.size())) {
-            getSynthesizedExternsInputAtEnd()
-                .getAstRoot(this)
-                .addChildToBack(IR.var(IR.name(extern)));
-          }
-          break;
-        default:
-          throw new RuntimeException("Bad directive: " + directive);
+      String word = words.get(0);
+      if (word.equals("use")) {
+        // 'use strict' is ignored (and deleted).
+      } else if (word.equals("require")) {
+        // 'require lib1 lib2'; pulls in the named libraries before this one.
+        for (String dependency : words.subList(1, words.size())) {
+          ensureLibraryInjected(dependency, force);
+        }
+      } else if (word.equals("declare")) {
+        // 'declare name1 name2'; adds the names to the externs (with no type information).
+        // Note that we could simply add the entire externs library, but that leads to
+        // potentially-surprising behavior when the externs that are present depend on
+        // whether or not a polyfill is used.
+        for (String extern : words.subList(1, words.size())) {
+          getSynthesizedExternsInputAtEnd()
+              .getAstRoot(this)
+              .addChildToBack(IR.var(IR.name(extern)));
+        }
+      } else {
+        throw new RuntimeException("Bad directive: " + directive);
       }
       ast.removeChild(node);
     }

src/com/google/javascript/jscomp/CompilerOptions.java

@@ -2495,26 +2495,19 @@ public static LanguageMode fromString(String value) {
       if (value == null) {
         return null;
       }
-      switch (value) {
-        case "ECMASCRIPT6_STRICT":
-        case "ES6_STRICT":
-          return LanguageMode.ECMASCRIPT6_STRICT;
-        case "ECMASCRIPT6":
-        case "ES6":
-          return LanguageMode.ECMASCRIPT6;
-        case "ECMASCRIPT5_STRICT":
-        case "ES5_STRICT":
-          return LanguageMode.ECMASCRIPT5_STRICT;
-        case "ECMASCRIPT5":
-        case "ES5":
-          return LanguageMode.ECMASCRIPT5;
-        case "ECMASCRIPT3":
-        case "ES3":
-          return LanguageMode.ECMASCRIPT3;
-        case "ECMASCRIPT6_TYPED":
-        case "ES6_TYPED":
-          return LanguageMode.ECMASCRIPT6_TYPED;
-      }
+      if (value.equals("ECMASCRIPT6_STRICT") || value.equals("ES6_STRICT"))
+        return LanguageMode.ECMASCRIPT6_STRICT;
+      else if (value.equals("ECMASCRIPT6") || value.equals("ES6"))
+        return LanguageMode.ECMASCRIPT6;
+      else if (value.equals("ECMASCRIPT5_STRICT") || value.equals("ES5_STRICT"))
+        return LanguageMode.ECMASCRIPT5_STRICT;
+      else if (value.equals("ECMASCRIPT5") || value.equals("ES5"))
+        return LanguageMode.ECMASCRIPT5;
+      else if (value.equals("ECMASCRIPT3") || value.equals("ES3"))
+        return LanguageMode.ECMASCRIPT3;
+      else if (value.equals("ECMASCRIPT6_TYPED") || value.equals("ES6_TYPED"))
+        return LanguageMode.ECMASCRIPT6_TYPED;
+
       return null;
     }
   }

src/com/google/javascript/jscomp/GlobalTypeInfo.java

@@ -1054,35 +1054,24 @@ private void maybeRecordNominalType(
 
     private void maybeRecordBuiltinType(
         String name, RawNominalType rawType) {
-      switch (name) {
-        case "Arguments":
-          commonTypes.setArgumentsType(rawType);
-          break;
-        case "Function":
-          commonTypes.setFunctionType(rawType);
-          break;
-        case "Object":
-          commonTypes.setObjectType(rawType);
-          break;
-        case "Number":
-          commonTypes.setNumberInstance(rawType.getInstanceAsJSType());
-          break;
-        case "String":
-          commonTypes.setStringInstance(rawType.getInstanceAsJSType());
-          break;
-        case "Boolean":
-          commonTypes.setBooleanInstance(rawType.getInstanceAsJSType());
-          break;
-        case "RegExp":
-          commonTypes.setRegexpInstance(rawType.getInstanceAsJSType());
-          break;
-        case "Array":
-          commonTypes.setArrayType(rawType);
-          break;
-        case "IObject":
-          commonTypes.setIObjectType(rawType);
-          break;
-      }
+      if (name.equals("Arguments"))
+        commonTypes.setArgumentsType(rawType);
+      else if (name.equals("Function"))
+        commonTypes.setFunctionType(rawType);
+      else if (name.equals("Object"))
+        commonTypes.setObjectType(rawType);
+      else if (name.equals("Number"))
+        commonTypes.setNumberInstance(rawType.getInstanceAsJSType());
+      else if (name.equals("String"))
+        commonTypes.setStringInstance(rawType.getInstanceAsJSType());
+      else if (name.equals("Boolean"))
+        commonTypes.setBooleanInstance(rawType.getInstanceAsJSType());
+      else if (name.equals("RegExp"))
+        commonTypes.setRegexpInstance(rawType.getInstanceAsJSType());
+      else if (name.equals("Array"))
+        commonTypes.setArrayType(rawType);
+      else if (name.equals("IObject"))
+        commonTypes.setIObjectType(rawType);
     }
 
     private void visitAliasedNamespace(Node lhs) {

src/com/google/javascript/jscomp/J2clPropertyInlinerPass.java

@@ -200,17 +200,15 @@ public void visit(NodeTraversal t, Node n, Node parent) {
             if (!innerKey.isStringKey()) {
               continue;
             }
-            switch (innerKey.getString()) {
-              case "get":
-                if (matchesJ2clGetKeySignature(classNameString, innerKey)) {
-                  getKey = innerKey;
-                }
-                break;
-              case "set":
-                if (matchesJ2clSetKeySignature(classNameString, innerKey)) {
-                  setKey = innerKey;
-                }
-                break;
+            String innerKeyString = innerKey.getString();
+            if (innerKeyString.equals("get")) {
+              if (matchesJ2clGetKeySignature(classNameString, innerKey)) {
+                getKey = innerKey;
+              }
+            } else if (innerKeyString.equals("set")) {
+              if (matchesJ2clSetKeySignature(classNameString, innerKey)) {
+                setKey = innerKey;
+              }
             }
           }
           if (getKey != null && setKey != null) {

src/com/google/javascript/jscomp/JsdocToEs6TypedConverter.java

@@ -168,31 +168,29 @@ public static TypeDeclarationNode convertTypeNodeAST(Node n) {
           return convertTypeNodeAST(n.getFirstChild());
         case Token.STRING:
           String typeName = n.getString();
-          switch (typeName) {
-            case "boolean":
-              return booleanType();
-            case "number":
-              return numberType();
-            case "string":
-              return stringType();
-            case "null":
-            case "undefined":
-            case "void":
-              return null;
-            default:
-              TypeDeclarationNode root = namedType(typeName);
-              if (n.getChildCount() > 0 && n.getFirstChild().isBlock()) {
-                Node block = n.getFirstChild();
-                if ("Array".equals(typeName)) {
-                  return arrayType(convertTypeNodeAST(block.getFirstChild()));
-                }
-                return parameterizedType(root,
-                    Iterables.filter(
-                        Iterables.transform(block.children(), CONVERT_TYPE_NODE),
-                        Predicates.notNull()));
+          if (typeName.equals("boolean"))
+            return booleanType();
+          else if (typeName.equals("number"))
+            return numberType();
+          else if (typeName.equals("string"))
+            return stringType();
+          else if (typeName.equals("null") || typeName.equals("undefined") || typeName.equals("void"))
+            return null;
+          else {
+            TypeDeclarationNode root = namedType(typeName);
+            if (n.getChildCount() > 0 && n.getFirstChild().isBlock()) {
+              Node block = n.getFirstChild();
+              if ("Array".equals(typeName)) {
+                return arrayType(convertTypeNodeAST(block.getFirstChild()));
               }
-              return root;
+              return parameterizedType(root,
+                  Iterables.filter(
+                      Iterables.transform(block.children(), CONVERT_TYPE_NODE),
+                      Predicates.notNull()));
+            }
+            return root;
           }
+
         case Token.QMARK:
           Node child = n.getFirstChild();
           return child == null