Issue 8742. Preserve leading line comments during java2dart translation.

pkg/analyzer/lib/src/generated/constant.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'java_core.dart';
@@ skipping 316 matching lines @@
     }
     while (!_referenceGraph.isEmpty) {
       VariableElement element = _referenceGraph.removeSink();
       while (element != null) {
         computeValueFor(element);
         element = _referenceGraph.removeSink();
       }
       if (!_referenceGraph.isEmpty) {
         List<VariableElement> variablesInCycle = _referenceGraph.findCycle();
         if (variablesInCycle == null) {
+          //
+          // This should not happen. Either the graph should be empty, or there should be at least
+          // one sink, or there should be a cycle. If this does happen we exit to prevent an
+          // infinite loop.
+          //
           AnalysisEngine.instance.logger.logError("Exiting constant value computer with ${_referenceGraph.nodeCount} variables that are neither sinks nor in a cycle");
           return;
         }
         for (VariableElement variable in variablesInCycle) {
           generateCycleError(variablesInCycle, variable);
         }
         _referenceGraph.removeAllNodes(variablesInCycle);
       }
     }
   }
 
   /**
    * Compute a value for the given variable.
    *
    * @param variable the variable for which a value is to be computed
    */
   void computeValueFor(VariableElement variable) {
     VariableDeclaration declaration = _declarationMap[variable];
     if (declaration == null) {
+      //
+      // The declaration will be null when the variable was added to the graph as a result of being
+      // referenced by another variable but is not defined in the compilation units that were added
+      // to this computer. In such cases, the variable should already have a value associated with
+      // it, but we don't bother to check because there's nothing we can do about it at this point.
+      //
       return;
     }
     EvaluationResultImpl result = declaration.initializer.accept(new ConstantVisitor(_typeProvider));
     (variable as VariableElementImpl).evaluationResult = result;
     if (result is ErrorResult) {
       List<AnalysisError> errors = new List<AnalysisError>();
       for (ErrorResult_ErrorData data in result.errorData) {
         ASTNode node = data.node;
         Source source = variable.getAncestor(CompilationUnitElement).source;
         errors.add(new AnalysisError.con2(source, node.offset, node.length, data.errorCode, []));
@@ skipping 87 matching lines @@
         result = result.concatenate(_typeProvider, node, string.accept(this));
       }
     }
     return result;
   }
 
   EvaluationResultImpl visitBinaryExpression(BinaryExpression node) {
     EvaluationResultImpl leftResult = node.leftOperand.accept(this);
     EvaluationResultImpl rightResult = node.rightOperand.accept(this);
     TokenType operatorType = node.operator.type;
+    // 'null' is almost never good operand
     if (operatorType != TokenType.BANG_EQ && operatorType != TokenType.EQ_EQ) {
       if (leftResult is ValidResult && leftResult.isNull || rightResult is ValidResult && rightResult.isNull) {
         return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
       }
     }
+    // evaluate operator
     while (true) {
       if (operatorType == TokenType.AMPERSAND) {
         return leftResult.bitAnd(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
         return leftResult.logicalAnd(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.BANG_EQ) {
         return leftResult.notEqual(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.BAR) {
         return leftResult.bitOr(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.BAR_BAR) {
@@ skipping 22 matching lines @@
         return leftResult.add(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.STAR) {
         return leftResult.times(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.SLASH) {
         return leftResult.divide(_typeProvider, node, rightResult);
       } else if (operatorType == TokenType.TILDE_SLASH) {
         return leftResult.integerDivide(_typeProvider, node, rightResult);
       }
       break;
     }
+    // TODO(brianwilkerson) Figure out which error to report.
     return error(node, null);
   }
 
   EvaluationResultImpl visitBooleanLiteral(BooleanLiteral node) => valid2(_typeProvider.boolType, BoolState.from(node.value));
 
   EvaluationResultImpl visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     EvaluationResultImpl conditionResult = condition.accept(this);
     EvaluationResultImpl thenResult = node.thenExpression.accept(this);
     EvaluationResultImpl elseResult = node.elseExpression.accept(this);
@@ skipping 18 matching lines @@
     }
     InterfaceType thenType = (thenResult as ValidResult).value.type;
     InterfaceType elseType = (elseResult as ValidResult).value.type;
     return valid(thenType.getLeastUpperBound(elseType) as InterfaceType);
   }
 
   EvaluationResultImpl visitDoubleLiteral(DoubleLiteral node) => valid2(_typeProvider.doubleType, new DoubleState(node.value));
 
   EvaluationResultImpl visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (!node.isConst) {
+      // TODO(brianwilkerson) Figure out which error to report.
       return error(node, null);
     }
     ConstructorElement constructor = node.staticElement;
     if (constructor != null && constructor.isConst) {
       NodeList<Expression> arguments = node.argumentList.arguments;
       int argumentCount = arguments.length;
       List<DartObjectImpl> argumentValues = new List<DartObjectImpl>(argumentCount);
       Map<String, DartObjectImpl> namedArgumentValues = new Map<String, DartObjectImpl>();
       for (int i = 0; i < argumentCount; i++) {
         Expression argument = arguments[i];
@@ skipping 26 matching lines @@
           if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
             DartObjectImpl argumentValue = namedArgumentValues[parameter.name];
             if (argumentValue != null) {
               fieldMap[fieldName] = argumentValue;
             }
           } else if (i < argumentCount) {
             fieldMap[fieldName] = argumentValues[i];
           }
         }
       }
+      // TODO(brianwilkerson) This doesn't handle fields initialized in an initializer. We should be
+      // able to handle fields initialized by the superclass' constructor fairly easily, but other
+      // initializers will be harder.
       return valid2(definingClass, new GenericState(fieldMap));
     }
+    // TODO(brianwilkerson) Figure out which error to report.
     return error(node, null);
   }
 
   EvaluationResultImpl visitIntegerLiteral(IntegerLiteral node) => valid2(_typeProvider.intType, new IntState(node.value));
 
   EvaluationResultImpl visitInterpolationExpression(InterpolationExpression node) {
     EvaluationResultImpl result = node.expression.accept(this);
     if (result is ValidResult && !result.isBoolNumStringOrNull) {
       return error(node, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING);
     }
@@ skipping 54 matching lines @@
             LibraryElement library = enclosingElement.library;
             if (library.isDartCore) {
               EvaluationResultImpl leftArgument = arguments[0].accept(this);
               EvaluationResultImpl rightArgument = arguments[1].accept(this);
               return leftArgument.equalEqual(_typeProvider, node, rightArgument);
             }
           }
         }
       }
     }
+    // TODO(brianwilkerson) Figure out which error to report.
     return error(node, null);
   }
 
   EvaluationResultImpl visitNamedExpression(NamedExpression node) => node.expression.accept(this);
 
   EvaluationResultImpl visitNode(ASTNode node) => error(node, null);
 
   EvaluationResultImpl visitNullLiteral(NullLiteral node) => new ValidResult(null2);
 
   EvaluationResultImpl visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
 
   EvaluationResultImpl visitPrefixedIdentifier(PrefixedIdentifier node) {
+    // validate prefix
     SimpleIdentifier prefixNode = node.prefix;
     Element prefixElement = prefixNode.staticElement;
     if (prefixElement is! PrefixElement) {
       EvaluationResultImpl prefixResult = prefixNode.accept(this);
       if (prefixResult is! ValidResult) {
         return error(node, null);
       }
     }
+    // validate prefixed identifier
     return getConstantValue(node, node.staticElement);
   }
 
   EvaluationResultImpl visitPrefixExpression(PrefixExpression node) {
     EvaluationResultImpl operand = node.operand.accept(this);
     if (operand is ValidResult && operand.isNull) {
       return error(node, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
     }
     while (true) {
       if (node.operator.type == TokenType.BANG) {
         return operand.logicalNot(_typeProvider, node);
       } else if (node.operator.type == TokenType.TILDE) {
         return operand.bitNot(_typeProvider, node);
       } else if (node.operator.type == TokenType.MINUS) {
         return operand.negated(_typeProvider, node);
       }
       break;
     }
+    // TODO(brianwilkerson) Figure out which error to report.
     return error(node, null);
   }
 
   EvaluationResultImpl visitPropertyAccess(PropertyAccess node) => getConstantValue(node, node.propertyName.staticElement);
 
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(node, node.staticElement);
 
   EvaluationResultImpl visitSimpleStringLiteral(SimpleStringLiteral node) => valid2(_typeProvider.stringType, new StringState(node.value));
 
   EvaluationResultImpl visitStringInterpolation(StringInterpolation node) {
@@ skipping 47 matching lines @@
         return value;
       }
     } else if (element is ExecutableElement) {
       ExecutableElement function = element;
       if (function.isStatic) {
         return valid2(_typeProvider.functionType, new FunctionState(function));
       }
     } else if (element is ClassElement || element is FunctionTypeAliasElement) {
       return valid2(_typeProvider.typeType, new TypeState(element));
     }
+    // TODO(brianwilkerson) Figure out which error to report.
     return error(node, null);
   }
 
   /**
    * Return an object representing the value 'null'.
    *
    * @return an object representing the value 'null'
    */
   DartObjectImpl get null2 {
     if (_nullObject == null) {
@@ skipping 73 matching lines @@
   Map<N, Set<N>> _edges = new Map<N, Set<N>>();
 
   /**
    * Add an edge from the given head node to the given tail node. Both nodes will be a part of the
    * graph after this method is invoked, whether or not they were before.
    *
    * @param head the node at the head of the edge
    * @param tail the node at the tail of the edge
    */
   void addEdge(N head, N tail) {
+    //
+    // First, ensure that the tail is a node known to the graph.
+    //
     Set<N> tails = _edges[tail];
     if (tails == null) {
       _edges[tail] = new Set<N>();
     }
+    //
+    // Then create the edge.
+    //
     tails = _edges[head];
     if (tails == null) {
       tails = new Set<N>();
       _edges[head] = tails;
     }
     tails.add(tail);
   }
 
   /**
    * Add the given node to the set of nodes in the graph.
@@ skipping 1016 matching lines @@
    */
   DartObjectImpl add(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.add(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
+    // We should never get here.
     throw new IllegalStateException("add returned a ${result.runtimeType.toString()}");
   }
 
   /**
    * Return the result of invoking the '&' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
@@ skipping 64 matching lines @@
    */
   DartObjectImpl divide(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.divide(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
+    // We should never get here.
     throw new IllegalStateException("divide returned a ${result.runtimeType.toString()}");
   }
 
   /**
    * Return the result of invoking the '==' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '==' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
@@ skipping 167 matching lines @@
    */
   DartObjectImpl minus(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.minus(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
+    // We should never get here.
     throw new IllegalStateException("minus returned a ${result.runtimeType.toString()}");
   }
 
   /**
    * Return the result of invoking the '-' operator on this object.
    *
    * @param typeProvider the type provider used to find known types
    * @return the result of invoking the '-' operator on this object
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl negated(TypeProvider typeProvider) {
     InstanceState result = _state.negated();
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
+    // We should never get here.
     throw new IllegalStateException("negated returned a ${result.runtimeType.toString()}");
   }
 
   /**
    * Return the result of invoking the '!=' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '!=' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
@@ skipping 33 matching lines @@
    */
   DartObjectImpl remainder(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.remainder(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
+    // We should never get here.
     throw new IllegalStateException("remainder returned a ${result.runtimeType.toString()}");
   }
 
   /**
    * Return the result of invoking the '&lt;&lt;' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '&lt;&lt;' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
@@ skipping 20 matching lines @@
    */
   DartObjectImpl times(TypeProvider typeProvider, DartObjectImpl rightOperand) {
     InstanceState result = _state.times(rightOperand._state);
     if (result is IntState) {
       return new DartObjectImpl(typeProvider.intType, result);
     } else if (result is DoubleState) {
       return new DartObjectImpl(typeProvider.doubleType, result);
     } else if (result is NumState) {
       return new DartObjectImpl(typeProvider.numType, result);
     }
+    // We should never get here.
     throw new IllegalStateException("times returned a ${result.runtimeType.toString()}");
   }
 
   String toString() => "${type.displayName} (${_state.toString()})";
 }
 
 /**
  * Instances of the class `DoubleState` represent the state of an object representing a
  * double.
  */
@@ skipping 1849 matching lines @@
     }
     return BoolState.FALSE_STATE;
   }
 
   String get typeName => "Type";
 
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   String toString() => _element == null ? "-unknown-" : _element.name;
 }