2.4/build-tools/customchecks/src/com/google/gwt/checkstyle/OrderCheck.java

// CHECKSTYLE_OFF:Must use GNU license for code based on checkstyle
// /////////////////////////////////////////////////////////////////////////////
// checkstyle: Checks Java source code for adherence to a set of rules.
// Copyright (C) 2001-2005 Oliver Burn
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// //////////////////////////////////////////////////////////////////////////////
// CHECKSTYLE_ON

// This class is based upon the
// com.puppycrawl.tools.checkstyle.checks.coding.DeclarationOrderCheck

package com.google.gwt.checkstyle;

import com.puppycrawl.tools.checkstyle.api.Check;
import com.puppycrawl.tools.checkstyle.api.DetailAST;
import com.puppycrawl.tools.checkstyle.api.Scope;
import com.puppycrawl.tools.checkstyle.api.ScopeUtils;
import com.puppycrawl.tools.checkstyle.api.TokenTypes;

import java.util.Stack;

/**
 * Checks that the parts of a class or interface declaration appear in the order
 * specified by the 'Making GWT better' style guide.
 */

public class OrderCheck extends Check {
  /**
   * Encapsulate the state in each class scope in order to handle inner classes.
   */
  private static class ScopeState {
    /**
     * Current state.
     */
    private int state = State.TYPE;

    /**
     * Current access modifier for state.
     */
    private Scope visibility = Scope.PUBLIC;
  }

  /**
   * Ordered category states for code elements.
   */
  private static class State {
    private static final int TYPE = 0;
    private static final int STATIC_FIELDS = 1;
    private static final int STATIC_INITS = 2;
    private static final int STATIC_METHODS = 3;
    private static final int INSTANCE_FIELDS = 4;
    private static final int INSTANCE_INITS = 5;
    private static final int CONSTRUCTORS = 6;
    private static final int INSTANCE_METHODS = 7;
  }

  /**
   * List of Declaration States. This is necessary due to inner classes that
   * have their own state.
   */
  private final Stack<ScopeState> classScopes = new Stack<ScopeState>();

  /**
   * Previous method name, used for alphabetical ordering.
   */
  private String previousMethodName;

  public int[] getDefaultTokens() {
    return new int[] {
        TokenTypes.CTOR_DEF, TokenTypes.METHOD_DEF, TokenTypes.MODIFIERS,
        TokenTypes.STATIC_INIT, TokenTypes.INSTANCE_INIT, TokenTypes.OBJBLOCK};
  }

  public void leaveToken(DetailAST aAST) {
    switch (aAST.getType()) {
      case TokenTypes.OBJBLOCK:
        classScopes.pop();
        previousMethodName = null;
        break;
      case TokenTypes.METHOD_DEF:
        // If the previous method was in the same class, with the same
        // modifiers, check that it is alphabetically before the current
        // method.
        String methodName = aAST.findFirstToken(TokenTypes.IDENT).getText();
        if (previousMethodName != null
            && (previousMethodName.compareToIgnoreCase(methodName)) > 0) {
          log(aAST, methodName + " is not alphabetical.");
        }
        previousMethodName = methodName;
        break;
      default:
    }
  }

  public void visitToken(DetailAST aAST) {
    try {
      int parentType = 0;
      if (aAST.getParent() != null) {
        parentType = aAST.getParent().getType();
      }
      switch (aAST.getType()) {
        case TokenTypes.OBJBLOCK:
          classScopes.push(new ScopeState());
          previousMethodName = null;
          break;

        case TokenTypes.CTOR_DEF:
          if (parentType != TokenTypes.OBJBLOCK) {
            return;
          }
          checkState(aAST, State.CONSTRUCTORS, "Constructor");
          break;

        case TokenTypes.MODIFIERS:
          if (parentType == TokenTypes.VARIABLE_DEF) {
            checkVariable(aAST);
          }
          if (parentType == TokenTypes.METHOD_DEF) {
            checkMethod(aAST);
          }
          break;
        case TokenTypes.STATIC_INIT: {
          checkState(aAST, State.STATIC_INITS, "Static initializer");
          break;
        }
        case TokenTypes.INSTANCE_INIT: {
          checkState(aAST, State.INSTANCE_INITS, "Instance initializer");
        }
          break;
        default:
      }
    } catch (Throwable t) {
      // CheckStyle swallows errors in general, we want OrderCheck errors to be
      // visible.
      t.printStackTrace();
      throw new RuntimeException("Exception/Error in OrderCheck", t);
    }
  }

  /**
   * Check the modifiers of a method for order conflicts.
   */
  private void checkMethod(DetailAST aAST) {
    if (aAST.getParent().getParent().getType() != TokenTypes.OBJBLOCK) {
      return;
    }
    if (aAST.findFirstToken(TokenTypes.LITERAL_STATIC) != null) {
      if (checkState(aAST, State.STATIC_METHODS, "Static method")) {
        previousMethodName = null;
      }
    } else {
      if (checkState(aAST, State.INSTANCE_METHODS, "Instance method")) {
        previousMethodName = null;
      }
    }
  }

  /**
   * Checks the category and visibility of declarations.
   * 
   * @return whether the state or visibility modifiers have changed
   */
  private boolean checkState(DetailAST aAST, int curState, String type) {
    ScopeState scope = classScopes.peek();
    if (scope.state > curState) {
      log(aAST, type + " in wrong order.");
      // Wrong type implies at least a temporary state switch.
      return true;
    } else if (scope.state == curState) {
      final Scope curVisibility = ScopeUtils.getScopeFromMods(aAST);
      if (scope.visibility.compareTo(curVisibility) > 0) {
        log(aAST, curVisibility.getName() + " " + type
            + " should not occur after " + scope.visibility.getName() + " "
            + type);
        return false;
      } else if (scope.visibility != curVisibility) {
        scope.visibility = curVisibility;
        return true;
      } else {
        return false;
      }
    } else {
      scope.state = curState;
      scope.visibility = Scope.PUBLIC;
      return true;
    }
  }

  /**
   * Check the modifiers of a variable for order conflicts.
   */
  private void checkVariable(DetailAST aAST) {
    if (aAST.getParent().getParent().getType() != TokenTypes.OBJBLOCK) {
      return;
    }
    if (aAST.findFirstToken(TokenTypes.LITERAL_STATIC) != null) {
      checkState(aAST, State.STATIC_FIELDS, "Static field");
    } else {
      checkState(aAST, State.INSTANCE_FIELDS, "Instance field");
    }
  }
}