Hide inference hints. Fixes #24563.

pkg/analyzer/lib/src/generated/resolver.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.
 
 library engine.resolver;
 
 import 'dart:collection';
 
 import '../task/strong/info.dart' show InferredType, StaticInfo;
 import '../task/strong/rules.dart' show TypeRules;
@@ skipping 5754 matching lines @@
   // hash table help in an instance of this class.
   static const String _typeProperty =
       'analyzer.src.generated.InferenceContext.contextType';
 
   /**
    * The error listener on which to record inference information.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
+   * If true, emit hints when types are inferred
+   */
+  final bool _inferenceHints;
+
+  /**
    * Type provider, needed for type matching.
    */
   final TypeProvider _typeProvider;
 
   /**
    * The type system in use.
    */
   final TypeSystem _typeSystem;
 
   /**
    * The DDC type rules, used to create the inference info nodes.
    */
   final TypeRules _rules;
 
   /**
    * A stack of return types for all of the enclosing
    * functions and methods.
    */
   List<DartType> _returnStack = <DartType>[];
 
-  InferenceContext._(
-      this._errorListener, TypeProvider typeProvider, this._typeSystem)
+  InferenceContext._(this._errorListener, TypeProvider typeProvider,
+      this._typeSystem, this._inferenceHints)
       : _typeProvider = typeProvider,
         _rules = new TypeRules(typeProvider);
 
   /**
    * Get the return type of the current enclosing function, if any.
    */
   DartType get returnContext =>
       (_returnStack.isNotEmpty) ? _returnStack.last : null;
 
   /**
@@ skipping 23 matching lines @@
   void pushReturnContext(DartType returnType) {
     _returnStack.add(returnType);
   }
 
   /**
    * Place an info node into the error stream indicating that a
    * [type] has been inferred as the type of [node].
    */
   void recordInference(Expression node, DartType type) {
     StaticInfo info = InferredType.create(_rules, node, type);
-    if (info == null) {
+    if (!_inferenceHints || info == null) {
       return;
     }
     AnalysisError error = info.toAnalysisError();
     _errorListener.onError(error);
   }
 
   List<DartType> _matchTypes(InterfaceType t1, InterfaceType t2) {
     if (t1 == t2) {
       return t2.typeArguments;
     }
@@ skipping 4837 matching lines @@
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     if (inheritanceManager == null) {
       this._inheritanceManager = new InheritanceManager(definingLibrary);
     } else {
       this._inheritanceManager = inheritanceManager;
     }
     this.elementResolver = new ElementResolver(this);
     this.typeSystem = definingLibrary.context.typeSystem;
-    this.inferenceContext =
-        new InferenceContext._(errorListener, typeProvider, typeSystem);
+    bool strongModeHints = false;
+    AnalysisOptions options = definingLibrary.context.analysisOptions;
+    if (options is AnalysisOptionsImpl) {
+      strongModeHints = options.strongModeHints;
+    }
+    this.inferenceContext = new InferenceContext._(
+        errorListener, typeProvider, typeSystem, strongModeHints);
     if (typeAnalyzerFactory == null) {
       this.typeAnalyzer = new StaticTypeAnalyzer(this);
     } else {
       this.typeAnalyzer = typeAnalyzerFactory(this);
     }
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
@@ skipping 5349 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }