* Copyright 2013 The Closure Compiler Authors.

*

* 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.

*/

* IRFactory transforms the external AST to the internal AST.

*/

  static final String GETTER_ERROR_MESSAGE =

      "getters are not supported in older versions of JavaScript. " +

      "If you are targeting newer versions of JavaScript, " +

      "set the appropriate language_in option.";

  static final String SETTER_ERROR_MESSAGE =

      "setters are not supported in older versions of JavaScript. " +

      "If you are targeting newer versions of JavaScript, " +

      "set the appropriate language_in option.";

  static final String SUSPICIOUS_COMMENT_WARNING =

      "Non-JSDoc comment has annotations. " +

      "Did you mean to start it with '/**'?";

  static final String MISPLACED_TYPE_ANNOTATION =

      "Type annotations are not allowed here. Are you missing parentheses?";

  static final String INVALID_ES3_PROP_NAME =

      "Keywords and reserved words are not allowed as unquoted property " +

      "names in older versions of JavaScript. " +

      "If you are targeting newer versions of JavaScript, " +

      "set the appropriate language_in option.";

  static final String INVALID_ES5_STRICT_OCTAL =

      "Octal integer literals are not supported in Ecmascript 5 strict mode.";

  static final String INVALID_NUMBER_LITERAL =

      "Invalid number literal.";

  static final String STRING_CONTINUATION_ERROR =

      "String continuations are not supported in this language mode.";

  static final String STRING_CONTINUATION_WARNING =

      "String continuations are not recommended. See"

      + " https://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml#Multiline_string_literals";

  static final String BINARY_NUMBER_LITERAL_WARNING =

      "Binary integer literals are not supported in this language mode.";

  static final String OCTAL_NUMBER_LITERAL_WARNING =

      "Octal integer literals are not supported in this language mode.";

  static final String OCTAL_STRING_LITERAL_WARNING =

      "Octal literals in strings are not supported in this language mode.";

  static final String DUPLICATE_PARAMETER =

      "Duplicate parameter name \"%s\"";

  static final String DUPLICATE_LABEL =

      "Duplicate label \"%s\"";

  static final String UNLABELED_BREAK =

      "unlabelled break must be inside loop or switch";

  static final String UNEXPECTED_CONTINUE = "continue must be inside loop";

  static final String UNEXPECTED_LABLED_CONTINUE =

      "continue can only use labeles of iteration statements";

  static final String UNEXPECTED_RETURN = "return must be inside function";

  static final String UNDEFINED_LABEL = "undefined label \"%s\"";

  private final String sourceString;

  private final List<Integer> newlines;

  private final StaticSourceFile sourceFile;

  private final String sourceName;

  private final Config config;

  private final ErrorReporter errorReporter;

  private final TransformDispatcher transformDispatcher;

  private static final ImmutableSet<String> ALLOWED_DIRECTIVES =

      ImmutableSet.of("use strict");

  private static final ImmutableSet<String> ES5_RESERVED_KEYWORDS =

      ImmutableSet.of(

          // From Section 7.6.1.2

          "class", "const", "enum", "export", "extends", "import", "super");

  private static final ImmutableSet<String> ES5_STRICT_RESERVED_KEYWORDS =

      ImmutableSet.of(

          // From Section 7.6.1.2

          "class", "const", "enum", "export", "extends", "import", "super",

          "implements", "interface", "let", "package", "private", "protected",

          "public", "static", "yield");

  private final Set<String> reservedKeywords;

  private final Set<Comment> parsedComments = Sets.newHashSet();

  // @license text gets appended onto the fileLevelJsDocBuilder as found,

  // and stored in JSDocInfo for placeholder node.

  Node rootNodeJsDocHolder = new Node(Token.SCRIPT);

  Node.FileLevelJsDocBuilder fileLevelJsDocBuilder =

      rootNodeJsDocHolder.getJsDocBuilderForNode();

  JSDocInfo fileOverviewInfo = null;

  // Use a template node for properties set on all nodes to minimize the

  // memory footprint associated with these.

  private final Node templateNode;

  private final UnmodifiableIterator<Comment> nextCommentIter;

  private Comment currentComment;

  private boolean currentFileIsExterns = false;

  private NewIRFactory(String sourceString,

                    StaticSourceFile sourceFile,

                    Config config,

                    ErrorReporter errorReporter,

                    ImmutableList<Comment> comments) {

    this.sourceString = sourceString;

    this.nextCommentIter = comments.iterator();

    this.currentComment = nextCommentIter.hasNext() ? nextCommentIter.next() : null;

    this.newlines = Lists.newArrayList();

    this.sourceFile = sourceFile;

    // Pre-generate all the newlines in the file.

    for (int charNo = 0; true; charNo++) {

      charNo = sourceString.indexOf('\n', charNo);

      if (charNo == -1) {

        break;

      }

      newlines.add(Integer.valueOf(charNo));

    }

    // Sometimes this will be null in tests.

    this.sourceName = sourceFile == null ? null : sourceFile.getName();

    this.config = config;

    this.errorReporter = errorReporter;

    this.transformDispatcher = new TransformDispatcher();

    // The template node properties are applied to all nodes in this transform.

    this.templateNode = createTemplateNode();

    switch (config.languageMode) {

      case ECMASCRIPT3:

        reservedKeywords = null; // use TokenStream.isKeyword instead

        break;

      case ECMASCRIPT5:

        reservedKeywords = ES5_RESERVED_KEYWORDS;

        break;

      case ECMASCRIPT5_STRICT:

        reservedKeywords = ES5_STRICT_RESERVED_KEYWORDS;

        break;

      case ECMASCRIPT6:

        reservedKeywords = ES5_RESERVED_KEYWORDS;

        break;

      case ECMASCRIPT6_STRICT:

        reservedKeywords = ES5_STRICT_RESERVED_KEYWORDS;

        break;

      default:

        throw new IllegalStateException("unknown language mode");

    }

  }

  // Create a template node to use as a source of common attributes, this allows

  // the prop structure to be shared among all the node from this source file.

  // This reduces the cost of these properties to O(nodes) to O(files).

  private Node createTemplateNode() {

    // The Node type choice is arbitrary.

    Node templateNode = new Node(Token.SCRIPT);

    templateNode.setStaticSourceFile(sourceFile);

    return templateNode;

  }

  public static Node transformTree(ProgramTree tree,

                                   StaticSourceFile sourceFile,

                                   String sourceString,

                                   Config config,

                                   ErrorReporter errorReporter) {

    NewIRFactory irFactory = new NewIRFactory(sourceString, sourceFile,

        config, errorReporter, tree.sourceComments);

    // don't call transform as we don't want standard jsdoc handling.

    Node n = irFactory.justTransform(tree);

    irFactory.setSourceInfo(n, tree);

    if (tree.sourceComments != null) {

      for (Comment comment : tree.sourceComments) {

        if (comment.type == Comment.Type.JSDOC &&

            !irFactory.parsedComments.contains(comment)) {

          irFactory.handlePossibleFileOverviewJsDoc(comment);

        } else if (comment.type == Comment.Type.BLOCK) {

          irFactory.handleBlockComment(comment);

        }

      }

    }

    irFactory.setFileOverviewJsDoc(n);

    irFactory.validateAll(n);

    return n;

  }

  private void validateAll(Node n) {

    validate(n);

    for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {

      validateAll(c);

    }

  }

  private void validate(Node n) {

    validateTypeAnnotations(n);

    validateParameters(n);

    validateBreakContinue(n);

    validateReturn(n);

    validateLabel(n);

  }

  private void validateBreakContinue(Node n) {

    if (n.isBreak() || n.isContinue()) {

      Node labelName = n.getFirstChild();

      if (labelName != null) {

        Node parent = n.getParent();

        while (!parent.isLabel() || !labelsMatch(parent, labelName)) {

          if (parent.isFunction() || parent.isScript()) {

            // report missing label

            errorReporter.error(

                String.format(UNDEFINED_LABEL, labelName.getString()),

                sourceName,

                n.getLineno(), n.getCharno());

            break;

          }

          parent = parent.getParent();

        }

        if (parent.isLabel() && labelsMatch(parent, labelName)) {

          if (n.isContinue() && !isContinueTarget(parent.getLastChild())) {

            // report invalid continue target

            errorReporter.error(

                UNEXPECTED_LABLED_CONTINUE,

                sourceName,

                n.getLineno(), n.getCharno());

          }

        }

      } else {

        if (n.isContinue()) {

          Node parent = n.getParent();

          while (!isContinueTarget(parent)) {

            if (parent.isFunction() || parent.isScript()) {

              // report invalid continue

              errorReporter.error(

                  UNEXPECTED_CONTINUE,

                  sourceName,

                  n.getLineno(), n.getCharno());

              break;

            }

            parent = parent.getParent();

          }

        } else {

          Node parent = n.getParent();

          while (!isBreakTarget(parent)) {

            if (parent.isFunction() || parent.isScript()) {

              // report invalid break

              errorReporter.error(

                  UNLABELED_BREAK,

                  sourceName,

                  n.getLineno(), n.getCharno());

              break;

            }

            parent = parent.getParent();

          }

        }

      }

    }

  }

  private void validateReturn(Node n) {

    if (n.isReturn()) {

      Node parent = n;

      while ((parent = parent.getParent()) != null) {

        if (parent.isFunction()) {

          return;

        }

      }

      errorReporter.error(UNEXPECTED_RETURN,

          sourceName, n.getLineno(), n.getCharno());

    }

  }

  private static boolean isBreakTarget(Node n) {

    switch (n.getType()) {

      case Token.FOR:

      case Token.FOR_OF:

      case Token.WHILE:

      case Token.DO:

      case Token.SWITCH:

        return true;

    }

    return false;

  }

  private static boolean isContinueTarget(Node n) {

    switch (n.getType()) {

      case Token.FOR:

      case Token.FOR_OF:

      case Token.WHILE:

      case Token.DO:

        return true;

    }

    return false;

  }

  private static boolean labelsMatch(Node label, Node labelName) {

    return label.getFirstChild().getString().equals(labelName.getString());

  }

  private void validateParameters(Node n) {

    if (n.isParamList()) {

      Node c = n.getFirstChild();

      for (; c != null; c = c.getNext()) {

        if (!c.isName()) {

          continue;

        }

        Node sibling = c.getNext();

        for (; sibling != null; sibling = sibling.getNext()) {

          if (sibling.isName() && c.getString().equals(sibling.getString())) {

            errorReporter.warning(

                String.format(DUPLICATE_PARAMETER, c.getString()),

                sourceName,

                n.getLineno(), n.getCharno());

          }

        }

      }

    }

  }

  @SuppressWarnings("incomplete-switch")

  private void validateTypeAnnotations(Node n) {

    JSDocInfo info = n.getJSDocInfo();

    if (info != null && info.hasType()) {

      boolean valid = false;

      switch (n.getType()) {

        // Casts are valid

        case Token.CAST:

          valid = true;

          break;

        // Variable declarations are valid

        case Token.VAR:

        case Token.LET:

        case Token.CONST:

          valid = true;

          break;

        // Function declarations are valid

        case Token.FUNCTION:

          valid = isFunctionDeclaration(n);

          break;

        // Object literal properties, catch declarations and variable

        // initializers are valid.

        case Token.NAME:

          Node parent = n.getParent();

          switch (parent.getType()) {

            case Token.STRING_KEY:

            case Token.GETTER_DEF:

            case Token.SETTER_DEF:

            case Token.CATCH:

            case Token.FUNCTION:

            case Token.VAR:

            case Token.LET:

            case Token.CONST:

            case Token.PARAM_LIST:

              valid = true;

              break;

          }

          break;

        // Object literal properties are valid

        case Token.STRING_KEY:

        case Token.GETTER_DEF:

        case Token.SETTER_DEF:

          valid = true;

          break;

        // Property assignments are valid, if at the root of an expression.

        case Token.ASSIGN:

          valid = n.getParent().isExprResult()

            && (n.getFirstChild().isGetProp() || n.getFirstChild().isGetElem());

          break;

        case Token.GETPROP:

          valid = n.getParent().isExprResult() && n.isQualifiedName();

          break;

        case Token.CALL:

          valid = info.isDefine();

          break;

      }

      if (!valid) {

        errorReporter.warning(MISPLACED_TYPE_ANNOTATION,

            sourceName,

            n.getLineno(), n.getCharno());

      }

    }

  }

  private void validateLabel(Node n) {

    if (n.isLabel()) {

      Node labelName = n.getFirstChild();

      for (Node parent = n.getParent();

           parent != null && !parent.isFunction(); parent = parent.getParent()) {

        if (parent.isLabel() && labelsMatch(parent, labelName)) {

          errorReporter.error(

              String.format(DUPLICATE_LABEL, labelName.getString()),

              sourceName,

              n.getLineno(), n.getCharno());

          break;

        }

      }

    }

  }

  private void setFileOverviewJsDoc(Node irNode) {

    // Only after we've seen all @fileoverview entries, attach the

    // last one to the root node, and copy the found license strings

    // to that node.

    JSDocInfo rootNodeJsDoc = rootNodeJsDocHolder.getJSDocInfo();

    if (rootNodeJsDoc != null) {

      irNode.setJSDocInfo(rootNodeJsDoc);

      rootNodeJsDoc.setAssociatedNode(irNode);

    }

    if (fileOverviewInfo != null) {

      if ((irNode.getJSDocInfo() != null) &&

          (irNode.getJSDocInfo().getLicense() != null)) {

        fileOverviewInfo.setLicense(irNode.getJSDocInfo().getLicense());

      }

      irNode.setJSDocInfo(fileOverviewInfo);

      fileOverviewInfo.setAssociatedNode(irNode);

    }

  }

  private Node transformBlock(ParseTree node) {

    Node irNode = transform(node);

    if (!irNode.isBlock()) {

      if (irNode.isEmpty()) {

        irNode.setType(Token.BLOCK);

      } else {

        Node newBlock = newNode(Token.BLOCK, irNode);

        setSourceInfo(newBlock, irNode);

        irNode = newBlock;

      }

      irNode.setIsAddedBlock(true);

    }

    return irNode;

  }

  /**

   * Check to see if the given block comment looks like it should be JSDoc.

   */

  private void handleBlockComment(Comment comment) {

    Pattern p = Pattern.compile("(/|(\n[ \t]*))\\*[ \t]*@[a-zA-Z]+[ \t\n{]");

    if (p.matcher(comment.value).find()) {

      errorReporter.warning(

          SUSPICIOUS_COMMENT_WARNING,

          sourceName,

          lineno(comment.location.start),

          charno(comment.location.start));

    }

  }

  /**

   * @return true if the jsDocParser represents a fileoverview.

   */

  private boolean handlePossibleFileOverviewJsDoc(

      JsDocInfoParser jsDocParser) {

    if (jsDocParser.getFileOverviewJSDocInfo() != fileOverviewInfo) {

      fileOverviewInfo = jsDocParser.getFileOverviewJSDocInfo();

      if (fileOverviewInfo.isExterns()) {

        this.currentFileIsExterns = true;

      }

      return true;

    }

    return false;

  }

  private void handlePossibleFileOverviewJsDoc(Comment comment) {

    JsDocInfoParser jsDocParser = createJsDocInfoParser(comment);

    parsedComments.add(comment);

    handlePossibleFileOverviewJsDoc(jsDocParser);

  }

  private Comment getJsDoc(SourceRange location) {

    Comment closestPreviousComment = null;

    while (currentComment != null &&

        currentComment.location.end.offset <= location.start.offset) {

      if (currentComment.type == Comment.Type.JSDOC) {

        closestPreviousComment = currentComment;

      }

      if (this.nextCommentIter.hasNext()) {

        currentComment = this.nextCommentIter.next();

      } else {

        currentComment = null;

      }

    }

    return closestPreviousComment;

  }

  private Comment getJsDoc(ParseTree tree) {

    return getJsDoc(tree.location);

  }

  private Comment getJsDoc(

      com.google.javascript.jscomp.parsing.parser.Token token) {

    return getJsDoc(token.location);

  }

  private JSDocInfo handleJsDoc(Comment comment) {

    if (comment != null) {

      JsDocInfoParser jsDocParser = createJsDocInfoParser(comment);

      parsedComments.add(comment);

      if (!handlePossibleFileOverviewJsDoc(jsDocParser)) {

        return jsDocParser.retrieveAndResetParsedJSDocInfo();

      }

    }

    return null;

  }

  private JSDocInfo handleJsDoc(ParseTree node) {

    if (!shouldAttachJSDocHere(node)) {

      return null;

    }

    return handleJsDoc(getJsDoc(node));

  }

  private boolean shouldAttachJSDocHere(ParseTree tree) {

    switch (tree.type) {

      case EXPRESSION_STATEMENT:

        return false;

      case LABELLED_STATEMENT:

        return false;

      case CALL_EXPRESSION:

      case CONDITIONAL_EXPRESSION:

      case BINARY_OPERATOR:

      case MEMBER_EXPRESSION:

      case MEMBER_LOOKUP_EXPRESSION:

      case POSTFIX_EXPRESSION:

        ParseTree nearest = findNearestNode(tree);

        if (nearest.type == ParseTreeType.PAREN_EXPRESSION) {

          return false;

        }

        return true;

      default:

        return true;

    }

  }

  private static ParseTree findNearestNode(ParseTree tree) {

    while (true) {

      switch (tree.type) {

        case EXPRESSION_STATEMENT:

          tree = tree.asExpressionStatement().expression;

          continue;

        case CALL_EXPRESSION:

          tree = tree.asCallExpression().operand;

          continue;

        case BINARY_OPERATOR:

          tree = tree.asBinaryOperator().left;

          continue;

        case CONDITIONAL_EXPRESSION:

          tree = tree.asConditionalExpression().condition;

          continue;

        case MEMBER_EXPRESSION:

          tree = tree.asMemberExpression().operand;

          continue;

        case MEMBER_LOOKUP_EXPRESSION:

          tree = tree.asMemberLookupExpression().operand;

          continue;

        case POSTFIX_EXPRESSION:

          tree = tree.asPostfixExpression().operand;

          continue;

        default:

          return tree;

      }

    }

  }

  private JSDocInfo handleJsDoc(

      com.google.javascript.jscomp.parsing.parser.Token token) {

    return handleJsDoc(getJsDoc(token));

  }

  private boolean isFunctionDeclaration(Node n) {

    return n.isFunction() && isStmtContainer(n.getParent());

  }

  private static boolean isStmtContainer(Node n) {

    return n.isBlock() || n.isScript();

  }

  private Node transform(ParseTree tree) {

    JSDocInfo info = handleJsDoc(tree);

    Node node = justTransform(tree);

    if (info != null) {

      node = maybeInjectCastNode(tree, info, node);

      attachJSDoc(info, node);

    }

    setSourceInfo(node, tree);

    return node;

  }

  private static void attachJSDoc(JSDocInfo info, Node n) {

    info.setAssociatedNode(n);

    n.setJSDocInfo(info);

  }

  private Node maybeInjectCastNode(ParseTree node, JSDocInfo info, Node irNode) {

    if (node.type == ParseTreeType.PAREN_EXPRESSION

        && info.hasType()) {

      irNode = newNode(Token.CAST, irNode);

    }

    return irNode;

  }

  /**

   * NAMEs in parameters or variable declarations are special, because they can

   * have inline type docs attached.

   *

   * function f(/** string &#42;/ x) {}

   * annotates 'x' as a string.

   *

   * @see <a href="http://code.google.com/p/jsdoc-toolkit/wiki/InlineDocs">

   *   Using Inline Doc Comments</a>

   */

  private Node transformNodeWithInlineJsDoc(

      ParseTree node, boolean optionalInline) {

    JSDocInfo info = handleInlineJsDoc(node, optionalInline);

    Node irNode = justTransform(node);

    if (info != null) {

      irNode.setJSDocInfo(info);

    }

    setSourceInfo(irNode, node);

    return irNode;

  }

  private JSDocInfo handleInlineJsDoc(ParseTree node, boolean optional) {

    return handleInlineJsDoc(node.location, optional);

  }

  private JSDocInfo handleInlineJsDoc(

      com.google.javascript.jscomp.parsing.parser.Token token,

      boolean optional) {

    return handleInlineJsDoc(token.location, optional);

  }

  private JSDocInfo handleInlineJsDoc(

      SourceRange location,

      boolean optional) {

    Comment comment = getJsDoc(location);

    if (comment != null && (!optional || !comment.value.contains("@"))) {

      return parseInlineTypeDoc(comment);

    } else {

      return handleJsDoc(comment);

    }

  }

  private Node transformNumberAsString(LiteralToken token) {

    double value = normalizeNumber(token);

    Node irNode = newStringNode(getStringValue(value));

    JSDocInfo jsDocInfo = handleJsDoc(token);

    if (jsDocInfo != null) {

      irNode.setJSDocInfo(jsDocInfo);

    }

    setSourceInfo(irNode, token);

    return irNode;

  }

  private static String getStringValue(double value) {

    long longValue = (long) value;

    // Return "1" instead of "1.0"

    if (longValue == value) {

      return Long.toString(longValue);

    } else {

      return Double.toString(value);

    }

  }

  private static int lineno(ParseTree node) {

    // location lines start at zero, our AST starts at 1.

    return lineno(node.location.start);

  }

  private static int charno(ParseTree node) {

    return charno(node.location.start);

  }

  private static int lineno(SourcePosition location) {

    // location lines start at zero, our AST starts at 1.

    return location.line + 1;

  }