* Copyright (c) 2013 Puppet Labs, Inc. and other contributors, as listed below.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*   Puppet Labs

*/

   * The CollectChecker is used to check the validity of puppet CollectExpression

   */

  protected class CollectChecker {

    private final PolymorphicDispatcher<Void> collectCheckerDispatch = new PolymorphicDispatcher<Void>(

      "check", 1, 2, Collections.singletonList(this), new ErrorHandler<Void>() {

        public Void handle(Object[] params, Throwable e) {

          return handleError(params, e);

        }

      });

    public void check(AndExpression o) {

      doCheck(o.getLeftExpr());

      doCheck(o.getRightExpr());

    }

    public void check(AtExpression o, boolean left) {

      if(left)

        check(o);

    }

    public void check(EqualityExpression o) {

      doCheck(o.getLeftExpr(), Boolean.TRUE);

      doCheck(o.getRightExpr(), Boolean.FALSE);

    }

    public void check(EqualityExpression o, boolean left) {

      check(o);

    }

    public void check(Expression o) {

      acceptor.acceptError(

        "Expression type not allowed here.", o.eContainer(), o.eContainingFeature(), INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

    }

    public void check(Expression o, boolean left) {

      acceptor.acceptError(

        "Expression type not allowed as " + (left

            ? "left"

            : "right") + " expression.", o.eContainer(), o.eContainingFeature(), INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

    }

    public void check(LiteralBoolean o, boolean left) {

      if(left)

        check(o);

    }

    public void check(LiteralName o, boolean left) {

      // intrinsic check of LiteralName is enough

    }

    public void check(LiteralNameOrReference o, boolean left) {

      if(isNAME(o.getValue()))

        return; // ok both left and right

      if(!left && isCLASSREF(o.getValue())) // accept "type" if right

        return;

      acceptor.acceptError("Must be a name" + (!left

          ? " or type."

          : "."), o, PPPackage.Literals.LITERAL_NAME_OR_REFERENCE__VALUE, INSIGNIFICANT_INDEX, left

          ? IPPDiagnostics.ISSUE__NOT_NAME

          : IPPDiagnostics.ISSUE__NOT_NAME_OR_REF);

    }

    public void check(OrExpression o) {

      doCheck(o.getLeftExpr());

      doCheck(o.getRightExpr());

    }

    public void check(ParenthesisedExpression o) {

      doCheck(o.getExpr());

    }

    public void check(SelectorExpression o, boolean left) {

      if(left)

        check(o);

    }

    public void check(StringExpression o, boolean left) {

      // TODO: follow up if all types of StringExpression (single, double, and unquoted are supported).

      if(left)

        check(o);

    }

    public void check(VariableExpression o, boolean left) {

      // intrinsic variable check is enough

    }

    /**

     * Calls "collectCheck" in polymorphic fashion.

     *

     * @param o

     */

    public void doCheck(Object... o) {

      collectCheckerDispatch.invoke(o);

    }

    public Void handleError(Object[] params, Throwable e) {

      return Exceptions.throwUncheckedException(e);

    }

  }

  /**

   * Classifies ResourceExpression based on its content (regular, override, etc).

   */

  @Inject

  private PPClassifier classifier;

  final protected IMessageAcceptor acceptor;

  @Inject

  private PPPatternHelper patternHelper;

  @Inject

  private PPStringConstantEvaluator stringConstantEvaluator;

  private final Provider<IValidationAdvisor> validationAdvisorProvider;

  @Inject

  private PPExpressionEquivalenceCalculator eqCalculator;

  /**

   * Classes accepted as top level statements in a pp manifest.

   */

  private static final Class<?>[] topLevelExprClasses = { ResourceExpression.class, // resource, virtual, resource override

      RelationshipExpression.class, //

      CollectExpression.class, //

      AssignmentExpression.class, //

      IfExpression.class, //

      UnlessExpression.class, //

      CaseExpression.class, //

      ImportExpression.class, //

      FunctionCall.class, //

      MethodCall.class, //

      Definition.class, HostClassDefinition.class, //

      NodeDefinition.class, //

      AppendExpression.class, //

      SeparatorExpression.class //

  };

  /**

   * Classes accepted as RVALUE.

   */

  private static final Class<?>[] rvalueClasses = { StringExpression.class, // TODO: was LiteralString, follow up

      LiteralNameOrReference.class, // NAME and TYPE

      LiteralBoolean.class, //

      SelectorExpression.class, //

      VariableExpression.class, //

      LiteralList.class, //

      LiteralHash.class, //

      AtExpression.class, // HashArray access or ResourceReference are accepted

      // resource reference - see AtExpression

      FunctionCall.class, // i.e. only parenthesized form

      MethodCall.class, LiteralUndef.class, };

  private static final Class<?>[] expressionClasses = { InExpression.class, //

      MatchingExpression.class, //

      AdditiveExpression.class, //

      MultiplicativeExpression.class, //

      ShiftExpression.class, //

      UnaryMinusExpression.class, //

      UnaryNotExpression.class, //

      RelationalExpression.class, //

      EqualityExpression.class, //

      OrExpression.class, //

      AndExpression.class, };

  private static final String[] keywords = {

      "and", "or", "case", "default", "define", "import", "if", "elsif", "else", "inherits", "node", "in",

      "undef", "true", "false" };

  @Inject

  protected PPExpressionTypeNameProvider expressionTypeNameProvider;

  @Inject

  protected PPTypeEvaluator typeEvaluator;

  @Inject

  private PPGrammarAccess grammarAccess;

  private final ImmutableSet<EClass> extendedRelationshipClasses = ImmutableSet.of(

    PPPackage.Literals.VARIABLE_EXPRESSION, //

    PPPackage.Literals.DOUBLE_QUOTED_STRING, //

    PPPackage.Literals.SINGLE_QUOTED_STRING, //

    PPPackage.Literals.LITERAL_HASH, //

    PPPackage.Literals.LITERAL_LIST, //

    PPPackage.Literals.SELECTOR_EXPRESSION, //

    PPPackage.Literals.CASE_EXPRESSION, //

    PPPackage.Literals.COLLECT_EXPRESSION

  // ,

  );

  @Inject

  public PPJavaValidator(IGrammarAccess ga, Provider<IValidationAdvisor> validationAdvisorProvider) {

    acceptor = new ValidationBasedMessageAcceptor(this);

    this.validationAdvisorProvider = validationAdvisorProvider;

  }

  private IValidationAdvisor advisor() {

    return validationAdvisorProvider.get();

  }

  @Check

  public void checkAdditiveExpression(AdditiveExpression o) {

    checkOperator(o, "+", "-");

    checkNumericBinaryExpression(o);

  }

  @Check

  public void checkAppendExpression(AppendExpression o) {

    Expression leftExpr = o.getLeftExpr();

    if(!(leftExpr instanceof VariableExpression))

      acceptor.acceptError(

        "Not an appendable expression", o, PPPackage.Literals.BINARY_EXPRESSION__LEFT_EXPR,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NOT_APPENDABLE);

    else

      checkAssignability(o, (VariableExpression) leftExpr);

  }

  /**

   * Common functionality for $x = ... and $x += ...

   *

   * @param o

   *            the binary expr where varExpr is the leftExpr

   * @param varExpr

   *            the leftExpr of the given o BinaryExpression

   */

  private void checkAssignability(BinaryExpression o, VariableExpression varExpr) {

    // Variables in 'other namespaces' are not assignable.

    if(varExpr.getVarName().contains("::"))

      acceptor.acceptError("Cannot assign to variables in other namespaces", o, //

        PPPackage.Literals.BINARY_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX, //

        IPPDiagnostics.ISSUE__ASSIGNMENT_OTHER_NAMESPACE);

    // Decimal numeric variables are not assignable (clash with magic regexp variables)

    if(patternHelper.isDECIMALVAR(varExpr.getVarName()))

      acceptor.acceptError("Cannot assign to regular expression result variable", o, //

        PPPackage.Literals.BINARY_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX, //

        IPPDiagnostics.ISSUE__ASSIGNMENT_DECIMAL_VAR);

    // The name "$string" causes inline templates to produce the wrong content.

    // http://projects.puppetlabs.com/issues/14093

    ValidationPreference preference = advisor().assignmentToVarNamedString();

    if(preference.isWarningOrError() &&

        ("string".equals(varExpr.getVarName()) || "$string".equals(varExpr.getVarName()))) {

      warningOrError(

        acceptor, preference, "Assignment to $string will cause inline templates to fail", varExpr,

        IPPDiagnostics.ISSUE__ASSIGNMENT_TO_VAR_NAMED_STRING);

    }

  }

  @Check

  public void checkAssignmentExpression(AssignmentExpression o) {

    Expression leftExpr = o.getLeftExpr();

    if(!(leftExpr instanceof VariableExpression || leftExpr instanceof AtExpression))

      acceptor.acceptError(

        "Not an assignable expression", o, PPPackage.Literals.BINARY_EXPRESSION__LEFT_EXPR,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NOT_ASSIGNABLE);

    if(leftExpr instanceof VariableExpression)

      checkAssignability(o, (VariableExpression) leftExpr);

    // TODO: rhs is not validated, it allows expression, which includes rvalue, but some top level expressions

    // are probably not allowed (case?)

  }

  /**

   * Checks if an AtExpression is either a valid hash access, or a resource reference.

   * Use isStandardAtExpression to check if an AtExpression is one or the other.

   * Also see {@link #isStandardAtExpression(AtExpression)})

   *

   * @param o

   */

  @Check

  public void checkAtExpression(AtExpression o) {

    if(!isStandardAtExpression(o)) {

      checkAtExpressionAsResourceReference(o);

      return;

    }

    // Puppet grammar At expression is VARIABLE[expr]([expr])? (i.e. only one nested level).

    //

    final Expression leftExpr = o.getLeftExpr();

    if(leftExpr == null)

      acceptor.acceptError(

        "Expression left of [] is required", o, PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__REQUIRED_EXPRESSION);

    else if(!(leftExpr instanceof VariableExpression || (leftExpr instanceof LiteralNameOrReference && isFirstNameInTE((LiteralNameOrReference) leftExpr)))) {

      // then, the leftExpression *must* be an AtExpression with a leftExpr being a variable

      if(leftExpr instanceof AtExpression) {

        // older versions limited access to two levels.

        if(!advisor().allowMoreThan2AtInSequence()) {

          final Expression nestedLeftExpr = ((AtExpression) leftExpr).getLeftExpr();

          // if nestedLeftExpr is null, it is validated for the nested instance

          if(nestedLeftExpr != null &&

              !(nestedLeftExpr instanceof VariableExpression || (nestedLeftExpr instanceof LiteralNameOrReference && isFirstNameInTE((LiteralNameOrReference) nestedLeftExpr))))

            acceptor.acceptError(

              "Expression left of [] must be a variable.", nestedLeftExpr,

              PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX,

              IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

        }

      }

      else {

        acceptor.acceptError(

          "Expression left of [] must be a variable.", leftExpr,

          PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX,

          IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

      }

    }

    // -- check that there is exactly one parameter expression (the key)

    switch(o.getParameters().size()) {

      case 0:

        acceptor.acceptError(

          "Key/index expression is required", o, PPPackage.Literals.PARAMETERIZED_EXPRESSION__PARAMETERS,

          INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__REQUIRED_EXPRESSION);

        break;

      case 1:

        break; // ok

      default:

        acceptor.acceptError(

          "Multiple expressions are not allowed", o, PPPackage.Literals.PARAMETERIZED_EXPRESSION__PARAMETERS,

          INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

    }

    // // TODO: Check for valid expressions (don't know if any expression is acceptable)

    // for(Expression expr : o.getParameters()) {

    // //

    // }

  }

  /**

   * Checks that an AtExpression that acts as a ResourceReference is valid.

   *

   * @param resourceRef

   * @param errorStartText

   */

  public void checkAtExpressionAsResourceReference(AtExpression resourceRef) {

    final String errorStartText = "A resource reference";

    Expression leftExpr = resourceRef.getLeftExpr();

    if(leftExpr == null)

      acceptor.acceptError(

        errorStartText + " must start with a name or referece (was null).", resourceRef,

        PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__RESOURCE_REFERENCE_NO_REFERENCE);

    else {

      String name = leftExpr instanceof LiteralNameOrReference

          ? ((LiteralNameOrReference) leftExpr).getValue()

          : null;

      boolean isref = isCLASSREF(name);

      boolean isname = isNAME(name);

      if(!isref) {

        if(!isname)

          acceptor.acceptError(

            errorStartText + " must start with a [(deprecated) name, or] class reference.", resourceRef,

            PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX,

            IPPDiagnostics.ISSUE__NOT_CLASSREF);

        else

          acceptor.acceptWarning(

            errorStartText + " uses deprecated form of reference. Should start with upper case letter.",

            resourceRef, PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR, INSIGNIFICANT_INDEX,

            IPPDiagnostics.ISSUE__DEPRECATED_REFERENCE);

      }

    }

    if(resourceRef.getParameters().size() < 1)

      acceptor.acceptError(

        errorStartText + " must have at least one expression in list.", resourceRef,

        PPPackage.Literals.PARAMETERIZED_EXPRESSION__PARAMETERS, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__RESOURCE_REFERENCE_NO_PARAMETERS);

    // TODO: Possibly check valid expressions in the list, there are probably many illegal constructs valid in Puppet grammar

    // TODO: Handle all relaxations in the puppet model/grammar

    for(Expression expr : resourceRef.getParameters()) {

      if(expr instanceof LiteralRegex)

        acceptor.acceptError(

          errorStartText + " invalid resource reference parameter expression type.", resourceRef,

          PPPackage.Literals.PARAMETERIZED_EXPRESSION__PARAMETERS, resourceRef.getParameters().indexOf(expr),

          IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

    }

  }

  @Check

  public void checkAttributeAddition(AttributeOperation o) {

    if(!isNAME(o.getKey()))

      acceptor.acceptError(

        "Bad name format.", o, PPPackage.Literals.ATTRIBUTE_OPERATION__KEY, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__NOT_NAME);

    String op = o.getOp();

    if(!(op != null && (op.equals("=>") || op.equals("+>"))))

      acceptor.acceptError(

        "Bad operator.", o, PPPackage.Literals.ATTRIBUTE_OPERATION__OP, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__UNSUPPORTED_OPERATOR);

    if(o.getValue() == null)

      acceptor.acceptError(

        "Missing value expression", o, PPPackage.Literals.ATTRIBUTE_OPERATION__VALUE, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__NULL_EXPRESSION);

  }

  @Check

  public void checkAttributeOperations(AttributeOperations o) {

    final int count = o.getAttributes().size();

    EList<AttributeOperation> attrs = o.getAttributes();

    for(int i = 0; i < count - 1; i++) {

      INode n = NodeModelUtils.getNode(attrs.get(i));

      INode n2 = NodeModelUtils.getNode(attrs.get(i + 1));

      INode commaNode = null;

      for(commaNode = n.getNextSibling(); commaNode != null; commaNode = commaNode.getNextSibling())

        if(commaNode == n2)

          break;

        else if(commaNode instanceof LeafNode && ((LeafNode) commaNode).isHidden())

          continue;

        else

          break;

      if(commaNode == null || !",".equals(commaNode.getText())) {

        int expectOffset = n.getTotalOffset() + n.getTotalLength();

        acceptor.acceptError("Missing comma.", n.getSemanticElement(),

        // note that offset must be -1 as this ofter a hidden newline and this

        // does not work otherwise. Any quickfix needs to adjust the offset on replacement.

          expectOffset - 1, 2, IPPDiagnostics.ISSUE__MISSING_COMMA);

      }

    }

    // check for duplicate use of attribute/parameter

    Set<String> duplicates = Sets.newHashSet();

    Set<String> processed = Sets.newHashSet();

    AttributeOperations aos = o;

    // find duplicates

    for(AttributeOperation ao : aos.getAttributes()) {

      final String key = ao.getKey();

      if(processed.contains(key))

        duplicates.add(key);

      processed.add(key);

    }

    // mark all instances of duplicate name

    if(duplicates.size() > 0)

      for(AttributeOperation ao : aos.getAttributes())

        if(duplicates.contains(ao.getKey()))

          acceptor.acceptError(

            "Duplicate attribute: '" + ao.getKey() + "'", ao, PPPackage.Literals.ATTRIBUTE_OPERATION__KEY,

            IPPDiagnostics.ISSUE__RESOURCE_DUPLICATE_PARAMETER);

  }

  @Check

  public void checkBinaryExpression(BinaryExpression o) {

    if(o.getLeftExpr() == null)

      acceptor.acceptError(

        "A binary expression must have a left expr", o, PPPackage.Literals.BINARY_EXPRESSION__LEFT_EXPR,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NULL_EXPRESSION);

    if(o.getRightExpr() == null)

      acceptor.acceptError(

        "A binary expression must have a right expr", o, PPPackage.Literals.BINARY_EXPRESSION__RIGHT_EXPR,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NULL_EXPRESSION);

  }

  /**

   * Checks case literals that puppet will barf on:

   * - an unquoted text sequence that contains "."

   *

   * @param o

   */

  @Check

  public void checkCase(Case o) {

    internalCheckTopLevelExpressions(o.getStatements());

    ValidationPreference periodInCase = validationAdvisorProvider.get().periodInCase();

    if(periodInCase != ValidationPreference.IGNORE) {

      for(Expression value : o.getValues()) {

        if(value.eClass() == PPPackage.Literals.LITERAL_NAME_OR_REFERENCE) {

          String v = ((LiteralNameOrReference) value).getValue();

          if(v != null && v.contains(".")) {

            if(periodInCase == ValidationPreference.ERROR)

              acceptor.acceptError(

                "A case value containing '.' (period) must be quoted", value,

                IPPDiagnostics.ISSUE__REQUIRES_QUOTING);

            else

              acceptor.acceptWarning(

                "A case value containing '.' (period) should be quoted", value,

                IPPDiagnostics.ISSUE__REQUIRES_QUOTING);

          }

        }

      }

    }

  }

  @Check

  public void checkCaseExpression(CaseExpression o) {

    final Expression switchExpr = o.getSwitchExpr();

    boolean theDefaultIsSeen = false;

    // collect unreachable entries to avoid multiple unreachable markers for an entry

    Set<Integer> unreachables = Sets.newHashSet();

    Set<Integer> duplicates = Sets.newHashSet();

    List<Expression> caseExpressions = Lists.newArrayList();

    for(Case caze : o.getCases()) {

      for(Expression e : caze.getValues()) {

        caseExpressions.add(e);

        if(e instanceof LiteralDefault)

          theDefaultIsSeen = true;

      }

    }

    // if a default is seen it should (optionally) appear last

    if(theDefaultIsSeen) {

      IValidationAdvisor advisor = advisor();

      ValidationPreference shouldBeLast = advisor.caseDefaultShouldAppearLast();

      if(shouldBeLast.isWarningOrError()) {

        int last = caseExpressions.size() - 1;

        for(int i = 0; i < last; i++)

          if(caseExpressions.get(i) instanceof LiteralDefault)

            acceptor.accept(

              severity(shouldBeLast), "A 'default' should appear last", caseExpressions.get(i),

              IPPDiagnostics.ISSUE__DEFAULT_NOT_LAST);

      }

    }

    // Check duplicate by equivalence (mark as duplicate)

    // Check equality to switch expression (mark all others as unreachable),

    for(int i = 0; i < caseExpressions.size(); i++) {

      Expression e1 = caseExpressions.get(i);

      // if a case value is equivalent to the switch expression, all other are unreachable

      if(eqCalculator.isEquivalent(e1, switchExpr))

        for(int u = 0; u < caseExpressions.size(); u++)

          if(u != i)

            unreachables.add(u);

      // or if equal to the case expression e1, that this particular expression is a duplicate (mark both).

      for(int j = i + 1; j < caseExpressions.size(); j++)

        if(eqCalculator.isEquivalent(e1, caseExpressions.get(j)))

          duplicates.addAll(Lists.newArrayList(i, j));

    }

    // mark all that are unreachable

    for(Integer i : unreachables)

      acceptor.acceptWarning("Unreachable case", caseExpressions.get(i), IPPDiagnostics.ISSUE__UNREACHABLE);

    // mark all that are duplicates

    for(Integer i : duplicates)

      acceptor.acceptError("Duplicate case", caseExpressions.get(i), IPPDiagnostics.ISSUE__DUPLICATE_CASE);

  }

  @Check

  public void checkCollectExpression(CollectExpression o) {

    // -- the class reference must have valid class ref format

    final Expression classRefExpr = o.getClassReference();

    if(classRefExpr instanceof LiteralNameOrReference) {

      final String classRefString = ((LiteralNameOrReference) classRefExpr).getValue();

      if(!isCLASSREF(classRefString))

        acceptor.acceptError(

          "Not a well formed class reference.", o, PPPackage.Literals.COLLECT_EXPRESSION__CLASS_REFERENCE,

          INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NOT_CLASSREF);

    }

    else {

      acceptor.acceptError(

        "Not a class reference.", o, PPPackage.Literals.COLLECT_EXPRESSION__CLASS_REFERENCE,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NOT_CLASSREF);

    }

    // -- the rhs expressions do not allow a full set of expressions, an extensive search must be made

    // Note: queries must implement both IQuery and be UnaryExpressions

    UnaryExpression q = (UnaryExpression) o.getQuery();

    Expression queryExpr = q.getExpr();

    // null expression is accepted, if stated it must comply with the simplified expressions allowed

    // for a collect expression

    if(queryExpr != null) {

      CollectChecker cc = new CollectChecker();

      cc.doCheck(queryExpr);

    }

  }

  @Check

  public void checkDefinition(Definition o) {

    internalCheckTopLevelExpressions(o.getStatements());

    String typeLabel = o instanceof HostClassDefinition

        ? "class"

        : "define";

    // Can only be contained by manifest (global scope), or another class.

    EObject container = o.eContainer();

    if(!(container instanceof PuppetManifest || container instanceof HostClassDefinition))

      acceptor.acceptError(

        "A '" + typeLabel + "' may only appear at top level or directly inside a class.", o.eContainer(),

        o.eContainingFeature(), INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NOT_AT_TOPLEVEL_OR_CLASS);

    if(!isCLASSNAME(o.getClassName())) {

      // invalid name

      acceptor.acceptError(

        "Must be a valid name (each segment must start with lower case letter)", o,

        PPPackage.Literals.DEFINITION__CLASS_NAME, IPPDiagnostics.ISSUE__NOT_CLASSNAME);

    }

    else {

      // hyphen in name =

      ValidationPreference hyphens = advisor().hyphensInNames();

      if(hyphens.isWarningOrError()) {

        int hyphenIdx = o.getClassName().indexOf("-");

        if(hyphenIdx >= 0) {

          String message = "Hyphen '-' in name only unofficially supported in some puppet versions.";

          if(hyphens == ValidationPreference.WARNING)

            acceptor.acceptWarning(

              message, o, PPPackage.Literals.DEFINITION__CLASS_NAME, IPPDiagnostics.ISSUE__HYPHEN_IN_NAME);

          else

            acceptor.acceptError(

              message, o, PPPackage.Literals.DEFINITION__CLASS_NAME, IPPDiagnostics.ISSUE__HYPHEN_IN_NAME);

        }

      }

      // reserved ?

      if(PPReservedNameHelper.isReservedClassName(o.getClassName())) {

        acceptor.acceptError(

          "Reserved name", o, PPPackage.Literals.DEFINITION__CLASS_NAME, IPPDiagnostics.ISSUE__RESERVED_NAME);

      }

    }

  }

  @Check

  public void checkDefinitionArgument(DefinitionArgument o) {

    // -- LHS should be a variable, use of name is deprecated

    String argName = o.getArgName();

    ValidationPreference missingDollar;

    if(argName == null || argName.length() < 1)

      acceptor.acceptError(

        "Empty or null argument", o, PPPackage.Literals.DEFINITION_ARGUMENT__ARG_NAME, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__NOT_VARNAME);

    else if(!argName.startsWith("$")) {

      missingDollar = advisor().definitionParamterMissingDollar();

      warningOrError(

        acceptor, missingDollar, (missingDollar.isWarning()

            ? "Deprecation: "

            : "") + "Definition argument should start with $", o,

        PPPackage.Literals.DEFINITION_ARGUMENT__ARG_NAME, IPPDiagnostics.ISSUE__NOT_VARNAME);

    }

    else if(!isVARIABLE(argName))

      acceptor.acceptError(

        "Not a valid variable name", o, PPPackage.Literals.DEFINITION_ARGUMENT__ARG_NAME, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__NOT_VARNAME);

    else if(!isFirstNonDollarLowerCase(argName))

      acceptor.acceptError(

        "A parameter must start with a lower case letter", o, PPPackage.Literals.DEFINITION_ARGUMENT__ARG_NAME,

        INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__NOT_INITIAL_LOWERCASE);

    if(o.getOp() != null && !"=".equals(o.getOp()))

      acceptor.acceptError(

        "Must be an assignment operator '=' (not definition '=>')", o,

        PPPackage.Literals.DEFINITION_ARGUMENT__OP, IPPDiagnostics.ISSUE__NOT_ASSIGNMENT_OP);

    // -- RHS should be a rvalue

    internalCheckRvalueExpression(o.getValue());

  }

  @Check

  public void checkDefinitionArgumentList(DefinitionArgumentList o) {

    Set<String> seen = Sets.newHashSet();

    int lastWithoutDefault = -1;

    int counter = 0;

    EList<DefinitionArgument> arguments = o.getArguments();

    for(DefinitionArgument arg : arguments) {

      String s = arg.getArgName();

      if(s.startsWith("$"))

        s = s.substring(1);

      if(seen.contains(s)) {

        acceptor.acceptError(

          "Duplicate definition of parameter", arg, IPPDiagnostics.ISSUE__DUPLICATE_PARAMETER);

      }

      else

        seen.add(s);

      if(arg.getValue() == null)

        lastWithoutDefault = counter;

      counter++;

    }

    if(o.eContainer() instanceof Lambda) {

      int limit = arguments.size();

      for(int i = 0; i < limit; i++) {

        DefinitionArgument arg = arguments.get(i);

        if(arg.getValue() == null)

          continue;

        if(i < lastWithoutDefault)

          acceptor.acceptError(

            "A Lambda parameter with default can not appear before a parameter without default", arg,

            IPPDiagnostics.ISSUE__PARAM_DEFAULT_NOT_LAST);

      }

    }

    IValidationAdvisor advisor = advisor();

    ValidationPreference endComma = advisor.definitionArgumentListEndComma();

    if(endComma.isWarningOrError()) {

      // Check if list ends with optional comma.

      INode n = NodeModelUtils.getNode(o);

      for(INode i : n.getAsTreeIterable().reverse()) {

        if(",".equals(i.getText())) {

          EObject grammarE = i.getGrammarElement();

          if(grammarE instanceof RuleCall && "endComma".equals(((RuleCall) grammarE).getRule().getName())) {

            warningOrError(

              acceptor, endComma, "End comma not allowed in versions < 2.7.8", o, i.getOffset(),

              i.getLength(), IPPDiagnostics.ISSUE__ENDCOMMA);

            return;

          }

          return;

        }

      }

    }

  }

  @Check

  public void checkDoubleQuotedString(DoubleQuotedString o) {

    // Check if a verbatim part starting with '-' follows a VariableTE.

    // If so, issue configurable issue for the VariableTE

    //

    TextExpression previous = null;

    int idx = 0;

    IValidationAdvisor advisor = advisor();

    ValidationPreference hyphens = advisor.interpolatedNonBraceEnclosedHyphens();

    for(TextExpression te : o.getStringPart()) {

      if(idx > 0 && previous instanceof VariableTE && te instanceof VerbatimTE) {

        VerbatimTE verbatim = (VerbatimTE) te;

        if(verbatim.getText().startsWith("-")) {

          if(hyphens.isWarningOrError()) {

            warningOrError(

              acceptor, hyphens,

              "Interpolation continues past '-' in some puppet 2.7 versions", //

              o, PPPackage.Literals.DOUBLE_QUOTED_STRING__STRING_PART, idx - 1,

              IPPDiagnostics.ISSUE__INTERPOLATED_HYPHEN);

          }

        }

      }

      previous = te;

      idx++;

    }

    ValidationPreference booleansInStringForm = advisor.booleansInStringForm();

    BOOLEAN_STRING: if(booleansInStringForm.isWarningOrError()) {

      // Check if string contains "true" or "false"

      String constant = stringConstantEvaluator.doToString(o);

      if(constant == null)

        break BOOLEAN_STRING;

      constant = constant.trim();

      if("true".equals(constant) || "false".equals(constant))

        warningOrError(

          acceptor, booleansInStringForm, "This is not a boolean", o, IPPDiagnostics.ISSUE__STRING_BOOLEAN,

          constant);

    }

    // DQ_STRING_NOT_REQUIRED

    ValidationPreference dqStringNotRequired = advisor.dqStringNotRequired();

    if(dqStringNotRequired.isWarningOrError() && !hasInterpolation(o)) {

      // contains escape sequences?

      String constant = stringConstantEvaluator.doToString(o);

      if(!constant.contains("\\"))

        warningOrError(

          acceptor, dqStringNotRequired, "Double quoted string not required", o,

          IPPDiagnostics.ISSUE__DQ_STRING_NOT_REQUIRED);

    }

    // UNBRACED INTERPOLATION

    ValidationPreference unbracedInterpolation = advisor.unbracedInterpolation();

    if(unbracedInterpolation.isWarningOrError()) {

      for(TextExpression te : o.getStringPart()) {

        if(te.eClass().getClassifierID() == PPPackage.VARIABLE_TE) {

          warningOrError(

            acceptor, unbracedInterpolation, "Unbraced interpolation of variable", te,

            IPPDiagnostics.ISSUE__UNBRACED_INTERPOLATION);

        }

      }

    }

    // SINGLE INTERPOLATION

    ValidationPreference dqStringNotRequiredVariable = advisor.dqStringNotRequiredVariable();

    SINGLE_INTERPOLATION: if(dqStringNotRequiredVariable.isWarningOrError()) {

      if(o.getStringPart().size() == 1) {

        String replacement = null;

        TextExpression te = o.getStringPart().get(0);

        switch(te.eClass().getClassifierID()) {

          case PPPackage.VARIABLE_TE:

            replacement = ((VariableTE) te).getVarName();

            break;

          case PPPackage.EXPRESSION_TE:

            Expression expr = ((ExpressionTE) te).getExpression();

            expr = ((ParenthesisedExpression) expr).getExpr();

            if(expr instanceof LiteralNameOrReference)

              replacement = "$" + ((LiteralNameOrReference) expr).getValue();

            break;

          default:

            break SINGLE_INTERPOLATION;

        }

        if(replacement != null) {

          warningOrError(

            acceptor, dqStringNotRequiredVariable,

            "String contains single interpolated variable. Double quotes not required.", o,

            IPPDiagnostics.ISSUE__DQ_STRING_NOT_REQUIRED_VAR, replacement);

        }

      }

    }

  }

  @Check

  public void checkElseExpression(ElseExpression o) {

    internalCheckTopLevelExpressions(o.getStatements());

    EObject container = o.eContainer();

    if(container instanceof IfExpression || container instanceof ElseExpression ||

        container instanceof ElseIfExpression)

      return;

    if(container instanceof UnlessExpression) {

      if(advisor().allowUnlessElse())

        return;

      acceptor.acceptError(

        "'else' expression can only be used in an 'unless' in puppet version >= 3.2 --parser future", o,

        // o.eContainer(), o.eContainingFeature(), INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

    }

    acceptor.acceptError(

      "'else' expression can only be used in an 'if', 'else' or 'elsif'", o.eContainer(), o.eContainingFeature(),

      INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

  }

  @Check

  public void checkElseIfExpression(ElseIfExpression o) {

    internalCheckTopLevelExpressions(o.getThenStatements());

    EObject container = o.eContainer();

    if(container instanceof IfExpression || container instanceof ElseExpression ||

        container instanceof ElseIfExpression)

      return;

    acceptor.acceptError(

      "'elsif' expression can only be used in an 'if', 'else' or 'elsif'", o, o.eContainingFeature(),

      INSIGNIFICANT_INDEX, IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

  }

  @Check

  public void checkEqualityExpression(EqualityExpression o) {

    checkOperator(o, "==", "!=");

  }

  @Check

  public void checkFunctionCall(FunctionCall o) {

    if(!(o.getLeftExpr() instanceof LiteralNameOrReference))

      acceptor.acceptError(

        "Must be a name or reference.", o, PPPackage.Literals.PARAMETERIZED_EXPRESSION__LEFT_EXPR,

        IPPDiagnostics.ISSUE__NOT_NAME_OR_REF);

    // rest of validation - valid function - is done during linking

  }

  @Check

  public void checkHostClassDefinition(HostClassDefinition o) {

    // Checks performed by checkDefinition, and in PPResourceLinker

  }

  @Check

  public void checkIfExpression(IfExpression o) {

    internalCheckTopLevelExpressions(o.getThenStatements());

    Expression elseStatement = o.getElseStatement();

    if(elseStatement == null || elseStatement instanceof ElseExpression || elseStatement instanceof IfExpression ||

        elseStatement instanceof ElseIfExpression)

      return;

    acceptor.acceptError(

      "If Expression's else part can only be an 'if' or 'elsif'", o,

      PPPackage.Literals.IF_EXPRESSION__ELSE_STATEMENT, INSIGNIFICANT_INDEX,

      IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

  }

  @Check

  public void checkImportExpression(ImportExpression o) {

    if(o.getValues().size() <= 0)

      acceptor.acceptError(

        "Empty import - should be followed by at least one string.", o,

        PPPackage.Literals.IMPORT_EXPRESSION__VALUES, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__REQUIRED_EXPRESSION);

    // warn against interpolation in double quoted strings

    for(IQuotedString s : o.getValues()) {

      if(s instanceof DoubleQuotedString)

        if(hasInterpolation(s))

          acceptor.acceptWarning(

            "String has interpolation expressions that will not be evaluated", s,

            PPPackage.Literals.IMPORT_EXPRESSION__VALUES, o.getValues().indexOf(s),

            IPPDiagnostics.ISSUE__UNSUPPORTED_EXPRESSION);

    }

  }

  @Check

  public void checkInExpression(InExpression o) {

    checkOperator(o, "in");

  }

  @Check

  public void checkLambda(Lambda o) {

    if(!advisor().allowLambdas()) {

      acceptor.acceptError(

        "A Lambda expressions is only available in Puppet version >= 3.2 --parser future. (Change target preference?)",

        o, IPPDiagnostics.ISSUE__UNSUPPORTED_LAMBDA);

    }

    else {

      internalCheckTopLevelExpressions(o.getStatements());

    }

  }

  @Check

  public void checkLiteralName(LiteralName o) {

    if(!isNAME(o.getValue()))

      acceptor.acceptError(

        "Expected to comply with NAME rule", o, PPPackage.Literals.LITERAL_NAME__VALUE, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__NOT_NAME);

  }

  @Check

  public void checkLiteralNameOrReference(LiteralNameOrReference o) {

    if(isKEYWORD(o.getValue())) {

      acceptor.acceptError(

        "Reserved word.", o, PPPackage.Literals.LITERAL_NAME_OR_REFERENCE__VALUE, INSIGNIFICANT_INDEX,

        IPPDiagnostics.ISSUE__RESERVED_WORD);

      return;

    }

    if(isCLASSNAME_OR_REFERENCE(o.getValue()))

      return;

    acceptor.acceptError(

      "Must be a name or type (all segments must start with same case).", o,

      PPPackage.Literals.LITERAL_NAME_OR_REFERENCE__VALUE, INSIGNIFICANT_INDEX,

      IPPDiagnostics.ISSUE__NOT_NAME_OR_REF, o.getValue());

  }