Store literal values and invocations arguments only for constants and untyped literals.

pkg/analyzer/lib/src/summary/idl.dart

 // Copyright (c) 2015, 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 file is an "idl" style description of the summary format.  It
  * contains abstract classes which declare the interface for reading data from
  * summaries.  It is parsed and transformed into code that implements the
  * summary format.
  *
@@ skipping 2179 matching lines @@
    * Pop the top `n` values from the stack (where `n` is obtained from
    * [UnlinkedExpr.ints]) into a list (filled from the end) and take the next
    * `n` values from [UnlinkedExpr.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
    * stack (where `m` is obtained from [UnlinkedExpr.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke a constant constructor obtained
    * from [UnlinkedExpr.references], and push the resulting value back onto the
    * stack.
    *
+   * Arguments are skipped, and `0` are specified as the numbers of arguments
+   * on the stack, if the expression is not a constant. We store expression of
+   * variable initializers to perform top-level inference, and arguments are
+   * never used to infer types.
+   *
    * Note that for an invocation of the form `const a.b(...)` (where no type
    * arguments are specified), it is impossible to tell from the unresolved AST
    * alone whether `a` is a class name and `b` is a constructor name, or `a` is
    * a prefix name and `b` is a class name.  For consistency between AST based
    * and elements based summaries, references to default constructors are always
    * recorded as references to corresponding classes.
    */
   invokeConstructor,
 
   /**
@@ skipping 223 matching lines @@
    * values to create named arguments.  Then pop the top `m` values from the
    * stack (where `m` is obtained from [UnlinkedExpr.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke a method (or a function) with
    * the reference from [UnlinkedExpr.references].  If `k` is nonzero (where
    * `k` is obtained from [UnlinkedExpr.ints]), obtain `k` type arguments from
    * [UnlinkedExpr.references] and use them as generic type arguments for the
    * aforementioned method or function.  Push the result of the invocation onto
    * the stack.
    *
+   * Arguments are skipped, and `0` are specified as the numbers of arguments
+   * on the stack, if the expression is not a constant. We store expression of
+   * variable initializers to perform top-level inference, and arguments are
+   * never used to infer types.
+   *
    * In general `a.b` cannot not be distinguished between: `a` is a prefix and
    * `b` is a top-level function; or `a` is an object and `b` is the name of a
    * method.  This operation should be used for a sequence of identifiers
    * `a.b.b.c.d.e` ending with an invokable result.
    */
   invokeMethodRef,
 
   /**
    * Pop the top `n` values from the stack (where `n` is obtained from
    * [UnlinkedExpr.ints]) into a list (filled from the end) and take the next
    * `n` values from [UnlinkedExpr.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
    * stack (where `m` is obtained from [UnlinkedExpr.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke the method with the name from
    * [UnlinkedExpr.strings] of the target popped from the stack.  If `k` is
    * nonzero (where `k` is obtained from [UnlinkedExpr.ints]), obtain `k` type
    * arguments from [UnlinkedExpr.references] and use them as generic type
    * arguments for the aforementioned method.  Push the result of the
    * invocation onto the stack.
    *
+   * Arguments are skipped, and `0` are specified as the numbers of arguments
+   * on the stack, if the expression is not a constant. We store expression of
+   * variable initializers to perform top-level inference, and arguments are
+   * never used to infer types.
+   *
    * This operation should be used for invocation of a method invocation
    * where `target` is known to be an object instance.
    */
   invokeMethod,
 
   /**
    * Begin a new cascade section.  Duplicate the top value of the stack.
    */
   cascadeSectionBegin,
 
@@ skipping 851 matching lines @@
   @Id(11)
   int get visibleLength;
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   @informative
   @Id(12)
   int get visibleOffset;
 }