* Copyright 2008 Google Inc.

*

* Licensed under the Apache License, Version 2.0 (the "License"); you may not

* use this file except in compliance with the License. You may obtain a copy of

* the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

* License for the specific language governing permissions and limitations under

* the License.

*/

* Creates a JavaScript AST from a <code>JProgram</code> node.

*/

  private class CreateNamesAndScopesVisitor extends JVisitor {

    /**

     * Cache of computed Java source file names to URI strings for symbol

     * export. By using a cache we also ensure the miminum number of String

     * instances are serialized.

     */

    private final Map<String, String> fileNameToUriString = new HashMap<String, String>();

    private final Stack<JsScope> scopeStack = new Stack<JsScope>();

    @Override

    public void endVisit(JArrayType x, Context ctx) {

      JsName name = topScope.declareName(x.getName());

      names.put(x, name);

      recordSymbol(x, name);

    }

    @Override

    public void endVisit(JClassType x, Context ctx) {

      pop();

    }

    @Override

    public void endVisit(JsCastMap x, Context ctx) {

      /*

       * Intern JsCastMaps, at this stage, they are only present in Array initialization,

       * so we always intern them even if they occur once, since every array initialization

       * makes a copy.

       */

      internedCastMap.add(castMapToString(x));

    }

    @Override

    public void endVisit(JField x, Context ctx) {

      String name = x.getName();

      String mangleName = mangleName(x);

      if (x.isStatic()) {

        JsName jsName = topScope.declareName(mangleName, name);

        names.put(x, jsName);

        recordSymbol(x, jsName);

      } else {

        JsName jsName;

        if (specialObfuscatedFields.containsKey(x)) {

          jsName = peek().declareName(mangleNameSpecialObfuscate(x));

          jsName.setObfuscatable(false);

        } else {

          jsName = peek().declareName(mangleName, name);

        }

        names.put(x, jsName);

        recordSymbol(x, jsName);

      }

    }

    @Override

    public void endVisit(JInterfaceType x, Context ctx) {

      pop();

    }

    @Override

    public void endVisit(JLabel x, Context ctx) {

      if (names.get(x) != null) {

        return;

      }

      names.put(x, peek().declareName(x.getName()));

    }

    @Override

    public void endVisit(JLocal x, Context ctx) {

      // locals can conflict, that's okay just reuse the same variable

      JsScope scope = peek();

      JsName jsName = scope.declareName(x.getName());

      names.put(x, jsName);

    }

    @Override

    public void endVisit(JMethod x, Context ctx) {

      pop();

    }

    @Override

    public void endVisit(JParameter x, Context ctx) {

      names.put(x, peek().declareName(x.getName()));

    }

    @Override

    public void endVisit(JProgram x, Context ctx) {

      /*

       * put the null method and field into objectScope since they can be

       * referenced as instance on null-types (as determined by type flow)

       */

      JMethod nullMethod = x.getNullMethod();

      polymorphicNames.put(nullMethod, objectScope.declareName(nullMethod.getName()));

      JField nullField = x.getNullField();

      JsName nullFieldName = objectScope.declareName(nullField.getName());

      names.put(nullField, nullFieldName);

      /*

       * put nullMethod in the global scope, too; it's the replacer for clinits

       */

      nullFunc = createGlobalFunction("function " + nullMethod.getName() + "(){}");

      names.put(nullMethod, nullFunc.getName());

      /*

       * Create names for instantiable array types since JProgram.traverse()

       * doesn't iterate over them.

       */

      for (JArrayType arrayType : program.getAllArrayTypes()) {

        if (typeOracle.isInstantiatedType(arrayType)) {

          accept(arrayType);

        }

      }

      // Generate symbolic names for all query type ids.

      if (!output.shouldMinimize()) {

        setupSymbolicCastMaps();

      }

    }

    @Override

    public boolean visit(JClassType x, Context ctx) {

      // have I already been visited as a super type?

      JsScope myScope = classScopes.get(x);

      if (myScope != null) {

        push(myScope);

        return false;

      }

      // My seed function name

      JsName jsName = topScope.declareName(getNameString(x), x.getShortName());

      names.put(x, jsName);

      recordSymbol(x, jsName);

      // My class scope

      if (x.getSuperClass() == null) {

        myScope = objectScope;

      } else {

        JsScope parentScope = classScopes.get(x.getSuperClass());

        // Run my superclass first!

        if (parentScope == null) {

          accept(x.getSuperClass());

        }

        parentScope = classScopes.get(x.getSuperClass());

        assert (parentScope != null);

        /*

         * WEIRD: we wedge the global interface scope in between object and all

         * of its subclasses; this ensures that interface method names trump all

         * (except Object method names)

         */

        if (parentScope == objectScope) {

          parentScope = interfaceScope;

        }

        myScope = new JsNormalScope(parentScope, "class " + x.getShortName());

      }

      classScopes.put(x, myScope);

      push(myScope);

      return true;

    }

    @Override

    public boolean visit(JInterfaceType x, Context ctx) {

      // interfaces have no name at run time

      push(interfaceScope);

      return true;

    }

    @Override

    public boolean visit(JMethod x, Context ctx) {

      // my polymorphic name

      String name = x.getName();

      if (x.needsVtable()) {

        if (polymorphicNames.get(x) == null) {

          JsName polyName;

          if (x.isPrivate()) {

            polyName = interfaceScope.declareName(mangleNameForPrivatePoly(x), name);

          } else if (specialObfuscatedMethodSigs.containsKey(x.getSignature())) {

            polyName = interfaceScope.declareName(mangleNameSpecialObfuscate(x));

            polyName.setObfuscatable(false);

          } else {

            polyName = interfaceScope.declareName(mangleNameForPoly(x), name);

          }

          polymorphicNames.put(x, polyName);

        }

      }

      if (x.isAbstract()) {

        // just push a dummy scope that we can pop in endVisit

        push(null);

        return false;

      }

      // my global name

      JsName globalName = null;

      assert x.getEnclosingType() != null;

      String mangleName = mangleNameForGlobal(x);

      if (JProgram.isClinit(x)) {

        name = name + "_" + x.getEnclosingType().getShortName();

      }

      /*

       * Only allocate a name for a function if it is native, not polymorphic,

       * or stack-stripping is disabled.

       */

      if (!stripStack || !polymorphicNames.containsKey(x) || x.isNative()) {

        globalName = topScope.declareName(mangleName, name);

        names.put(x, globalName);

        recordSymbol(x, globalName);

      }

      JsFunction jsFunction;

      if (x.isNative()) {

        // set the global name of the JSNI peer

        JsniMethodBody body = (JsniMethodBody) x.getBody();

        jsFunction = body.getFunc();

        jsFunction.setName(globalName);

      } else {

        /*

         * It would be more correct here to check for an inline assignment, such

         * as var foo = function blah() {} and introduce a separate scope for

         * the function's name according to EcmaScript-262, but this would mess

         * up stack traces by allowing two inner scope function names to

         * obfuscate to the same identifier, making function names no longer a

         * 1:1 mapping to obfuscated symbols. Leaving them in global scope

         * causes no harm.

         */

        jsFunction = new JsFunction(x.getSourceInfo(), topScope, globalName, true);

      }

      if (polymorphicNames.containsKey(x)) {

        polymorphicJsFunctions.add(jsFunction);

      }

      methodBodyMap.put(x.getBody(), jsFunction);

      push(jsFunction.getScope());

      if (program.getIndexedMethods().contains(x)) {

        indexedFunctions =

            Maps.put(indexedFunctions, x.getEnclosingType().getShortName() + "." + x.getName(),

                jsFunction);

      }

      return true;

    }

    @Override

    public boolean visit(JTryStatement x, Context ctx) {

      accept(x.getTryBlock());

      List<JLocalRef> catchArgs = x.getCatchArgs();

      List<JBlock> catchBlocks = x.getCatchBlocks();

      for (int i = 0, c = catchArgs.size(); i < c; ++i) {

        JLocalRef arg = catchArgs.get(i);

        JBlock catchBlock = catchBlocks.get(i);

        JsCatch jsCatch = new JsCatch(x.getSourceInfo(), peek(), arg.getTarget().getName());

        JsParameter jsParam = jsCatch.getParameter();

        names.put(arg.getTarget(), jsParam.getName());

        catchMap.put(catchBlock, jsCatch);

        push(jsCatch.getScope());

        accept(catchBlock);

        pop();

      }

      // TODO: normalize this so it's never null?

      if (x.getFinallyBlock() != null) {

        accept(x.getFinallyBlock());

      }

      return false;

    }

    private JsFunction createGlobalFunction(String code) {

      try {

        List<JsStatement> stmts =

            JsParser.parse(SourceOrigin.UNKNOWN, topScope, new StringReader(code));

        assert stmts.size() == 1;

        JsExprStmt stmt = (JsExprStmt) stmts.get(0);

        List<JsStatement> globalStmts = jsProgram.getGlobalBlock().getStatements();

        globalStmts.add(0, stmt);

        return (JsFunction) stmt.getExpression();

      } catch (Exception e) {

        throw new InternalCompilerException("Unexpected exception parsing '" + code + "'", e);

      }

    }

    /**

     * Generate a file name URI string for a source info, for symbol data

     * export.

     */

    private String makeUriString(HasSourceInfo x) {

      String fileName = x.getSourceInfo().getFileName();

      if (fileName == null) {

        return null;

      }

      String uriString = fileNameToUriString.get(fileName);

      if (uriString == null) {

        uriString = StandardSymbolData.toUriString(fileName);

        fileNameToUriString.put(fileName, uriString);

      }

      return uriString;

    }

    private JsScope peek() {

      return scopeStack.peek();

    }

    private void pop() {

      scopeStack.pop();

    }

    private void push(JsScope scope) {

      scopeStack.push(scope);

    }

    private void recordSymbol(JReferenceType x, JsName jsName) {

      StringBuilder sb = new StringBuilder();

      sb.append('{');

      JsCastMap castMap = program.getCastMap(x);

      if (castMap != null) {

        boolean isFirst = true;

        for (JExpression expr : castMap.getExprs()) {

          JsQueryType queryType = (JsQueryType) expr;

          if (isFirst) {

            isFirst = false;

          } else {

            sb.append(',');

          }

          sb.append(queryType.getQueryId());

          sb.append(":1");

        }

      }

      sb.append('}');

      CastableTypeMap castableTypeMap = new StandardCastableTypeMap(sb.toString());

      StandardSymbolData symbolData =

          StandardSymbolData.forClass(x.getName(), x.getSourceInfo().getFileName(), x

              .getSourceInfo().getStartLine(), program.getQueryId(x), castableTypeMap,

              x instanceof JClassType || x instanceof JArrayType ? getSeedId(x) : -1);

      assert !symbolTable.containsKey(symbolData);

      symbolTable.put(symbolData, jsName);

    }

    private <T extends HasEnclosingType & HasName & HasSourceInfo> void recordSymbol(T x,

        JsName jsName) {

      /*

       * NB: The use of x.getName() can produce confusion in cases where a type

       * has both polymorphic and static dispatch for a method, because you

       * might see HashSet::$add() and HashSet::add(). Logically, these methods

       * should be treated equally, however they will be implemented with

       * separate global functions and must be recorded independently.

       *

       * Automated systems that process the symbol information can easily map

       * the statically-dispatched function by looking for method names that

       * begin with a dollar-sign and whose first parameter is the enclosing

       * type.

       */

      String methodSig;

      if (x instanceof JMethod) {

        StringBuilder sb = new StringBuilder();

        sb.append('(');

        JMethod method = ((JMethod) x);

        for (JType t : method.getOriginalParamTypes()) {

          sb.append(t.getJsniSignatureName());

        }

        sb.append(')');

        sb.append(method.getOriginalReturnType().getJsniSignatureName());

        methodSig = StringInterner.get().intern(sb.toString());

      } else {

        methodSig = null;

      }

      StandardSymbolData symbolData =

          StandardSymbolData.forMember(x.getEnclosingType().getName(), x.getName(), methodSig,

              makeUriString(x), x.getSourceInfo().getStartLine());

      assert !symbolTable.containsKey(symbolData) : "Duplicate symbol " + "recorded "

          + jsName.getIdent() + " for " + x.getName() + " and key " + symbolData.getJsniIdent();

      symbolTable.put(symbolData, jsName);

    }

    /**

     * Create more readable output by generating symbolic constants for query

     * ids.

     */

    private void setupSymbolicCastMaps() {

      namesByQueryId = new ArrayList<JsName>();

      for (JReferenceType type : program.getTypesByQueryId()) {

        String shortName;

        String longName;

        if (type instanceof JArrayType) {

          JArrayType arrayType = (JArrayType) type;

          JType leafType = arrayType.getLeafType();

          if (leafType instanceof JReferenceType) {

            shortName = ((JReferenceType) leafType).getShortName();

          } else {

            shortName = leafType.getName();

          }

          shortName += "_$" + arrayType.getDims();

          longName = getNameString(leafType) + "_$" + arrayType.getDims();

        } else {

          shortName = type.getShortName();

          longName = getNameString(type);

        }

        JsName name = topScope.declareName("Q$" + longName, "Q$" + shortName);

        namesByQueryId.add(name);

      }

      // TODO(cromwellian): see about moving this into an immortal type

      StringBuilder sb = new StringBuilder();

      sb.append("function makeCastMap(a) {");

      sb.append("  var result = {};");

      sb.append("  for (var i = 0, c = a.length; i < c; ++i) {");

      sb.append("    result[a[i]] = 1;");

      sb.append("  }");

      sb.append("  return result;");

      sb.append("}");

      makeMapFunction = createGlobalFunction(sb.toString());

    }

  }

  private class GenerateJavaScriptVisitor extends GenerateJavaScriptLiterals {

    private final Set<JClassType> alreadyRan = new HashSet<JClassType>();

    private final JsName arrayLength = objectScope.declareName("length");

    private final Set<String> castMapSeen = new HashSet<String>();

    private final Map<JClassType, JsFunction> clinitMap = new HashMap<JClassType, JsFunction>();

    private JMethod currentMethod = null;

    /**

     * The JavaScript functions corresponding to the entry methods of the

     * program ({@link JProgram#getEntryMethods()}).

     */

    private JsFunction[] entryFunctions;

    /**

     * A reverse index for the entry methods of the program (

     * {@link JProgram#getEntryMethods()}). Each entry method is mapped to its

     * integer index.

     */

    private Map<JMethod, Integer> entryMethodToIndex;

    private final JsName globalTemp = topScope.declareName("_");

    private final JsName prototype = objectScope.declareName("prototype");

    {

      globalTemp.setObfuscatable(false);

      prototype.setObfuscatable(false);

      arrayLength.setObfuscatable(false);

    }

    public GenerateJavaScriptVisitor() {

    }

   

    @Override

    public void endVisit(JAbsentArrayDimension x, Context ctx) {

      throw new InternalCompilerException("Should not get here.");

    }

    @Override

    public void endVisit(JArrayLength x, Context ctx) {

      assert x.getInstance() != null : "Can't access the length of a null array";

      JsExpression qualifier = (JsExpression) pop();

      JsNameRef ref = arrayLength.makeRef(x.getSourceInfo());

      ref.setQualifier(qualifier);

      push(ref);

    }

    @Override

    public void endVisit(JArrayRef x, Context ctx) {

      JsArrayAccess jsArrayAccess = new JsArrayAccess(x.getSourceInfo());

      jsArrayAccess.setIndexExpr((JsExpression) pop());

      jsArrayAccess.setArrayExpr((JsExpression) pop());

      push(jsArrayAccess);

    }

    @Override

    public void endVisit(JAssertStatement x, Context ctx) {

      throw new InternalCompilerException("Should not get here.");

    }

    @Override

    public void endVisit(JBinaryOperation x, Context ctx) {

      JsExpression rhs = (JsExpression) pop(); // rhs

      JsExpression lhs = (JsExpression) pop(); // lhs

      JsBinaryOperator myOp = JavaToJsOperatorMap.get(x.getOp());

      /*

       * Use === and !== on reference types, or else you can get wrong answers

       * when Object.toString() == 'some string'.

       */

      if (myOp == JsBinaryOperator.EQ && x.getLhs().getType() instanceof JReferenceType

          && x.getRhs().getType() instanceof JReferenceType) {

        myOp = JsBinaryOperator.REF_EQ;

      } else if (myOp == JsBinaryOperator.NEQ && x.getLhs().getType() instanceof JReferenceType

          && x.getRhs().getType() instanceof JReferenceType) {

        myOp = JsBinaryOperator.REF_NEQ;

      }

      push(new JsBinaryOperation(x.getSourceInfo(), myOp, lhs, rhs));

    }

    @Override

    public void endVisit(JBlock x, Context ctx) {

      JsBlock jsBlock = new JsBlock(x.getSourceInfo());

      List<JsStatement> stmts = jsBlock.getStatements();

      popList(stmts, x.getStatements().size()); // stmts

      Iterator<JsStatement> iterator = stmts.iterator();

      while (iterator.hasNext()) {

        JsStatement stmt = iterator.next();

        if (stmt instanceof JsEmpty) {

          iterator.remove();

        }

      }

      push(jsBlock);

    }

    @Override

    public void endVisit(JBreakStatement x, Context ctx) {

      JsNameRef labelRef = null;

      if (x.getLabel() != null) {

        JsLabel label = (JsLabel) pop(); // label

        labelRef = label.getName().makeRef(x.getSourceInfo());