Add isInline to ClassElement.

Change-Id: I80dafc9ef0dc03b8090032a7b7168302a8d6ad66
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/311150
Reviewed-by: Samuel Rawlins <srawlins@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: scheglov

pkg/analyzer/lib/dart/element/element.dart

@@ -228,6 +228,12 @@ abstract class ClassElement
   /// or mixed in.
   bool get isFinal;
 
+  /// Returns `true` if this class is an inline class.
+  ///
+  /// A class is an inline class if it has an explicit `inline` modifier.
+  @experimental
+  bool get isInline;
+
   /// Return `true` if this class is an interface class.
   ///
   /// A class is an interface class if it has an explicit `interface` modifier,

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -87,7 +87,7 @@ import 'package:analyzer/src/utilities/uri_cache.dart';
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 277;
+  static const int DATA_VERSION = 278;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/dart/element/element.dart

@@ -736,6 +736,15 @@ class ClassElementImpl extends ClassOrMixinElementImpl implements ClassElement {
     setModifier(Modifier.FINAL, isFinal);
   }
 
+  @override
+  bool get isInline {
+    return hasModifier(Modifier.INLINE);
+  }
+
+  set isInline(bool isInline) {
+    setModifier(Modifier.INLINE, isInline);
+  }
+
   @override
   bool get isInterface {
     return hasModifier(Modifier.INTERFACE);
@@ -5001,53 +5010,56 @@ class Modifier implements Comparable<Modifier> {
   /// type being referred to is the return type.
   static const Modifier IMPLICIT_TYPE = Modifier('IMPLICIT_TYPE', 18);
 
+  /// Indicates that the modifier 'inline' was applied to the element.
+  static const Modifier INLINE = Modifier('INLINE', 19);
+
   /// Indicates that the modifier 'interface' was applied to the element.
-  static const Modifier INTERFACE = Modifier('INTERFACE', 19);
+  static const Modifier INTERFACE = Modifier('INTERFACE', 20);
 
   /// Indicates that the method invokes the super method with the same name.
-  static const Modifier INVOKES_SUPER_SELF = Modifier('INVOKES_SUPER_SELF', 20);
+  static const Modifier INVOKES_SUPER_SELF = Modifier('INVOKES_SUPER_SELF', 21);
 
   /// Indicates that modifier 'lazy' was applied to the element.
-  static const Modifier LATE = Modifier('LATE', 21);
+  static const Modifier LATE = Modifier('LATE', 22);
 
   /// Indicates that a class is a macro builder.
-  static const Modifier MACRO = Modifier('MACRO', 22);
+  static const Modifier MACRO = Modifier('MACRO', 23);
 
   /// Indicates that a class is a mixin application.
-  static const Modifier MIXIN_APPLICATION = Modifier('MIXIN_APPLICATION', 23);
+  static const Modifier MIXIN_APPLICATION = Modifier('MIXIN_APPLICATION', 24);
 
   /// Indicates that a class is a mixin class.
-  static const Modifier MIXIN_CLASS = Modifier('MIXIN_CLASS', 24);
+  static const Modifier MIXIN_CLASS = Modifier('MIXIN_CLASS', 25);
 
-  static const Modifier PROMOTABLE = Modifier('IS_PROMOTABLE', 25);
+  static const Modifier PROMOTABLE = Modifier('IS_PROMOTABLE', 26);
 
   /// Indicates whether the type of a [PropertyInducingElementImpl] should be
   /// used to infer the initializer. We set it to `false` if the type was
   /// inferred from the initializer itself.
   static const Modifier SHOULD_USE_TYPE_FOR_INITIALIZER_INFERENCE =
-      Modifier('SHOULD_USE_TYPE_FOR_INITIALIZER_INFERENCE', 26);
+      Modifier('SHOULD_USE_TYPE_FOR_INITIALIZER_INFERENCE', 27);
 
   /// Indicates that the modifier 'sealed' was applied to the element.
-  static const Modifier SEALED = Modifier('SEALED', 27);
+  static const Modifier SEALED = Modifier('SEALED', 28);
 
   /// Indicates that the pseudo-modifier 'set' was applied to the element.
-  static const Modifier SETTER = Modifier('SETTER', 28);
+  static const Modifier SETTER = Modifier('SETTER', 29);
 
   /// See [TypeParameterizedElement.isSimplyBounded].
-  static const Modifier SIMPLY_BOUNDED = Modifier('SIMPLY_BOUNDED', 29);
+  static const Modifier SIMPLY_BOUNDED = Modifier('SIMPLY_BOUNDED', 30);
 
   /// Indicates that the modifier 'static' was applied to the element.
-  static const Modifier STATIC = Modifier('STATIC', 30);
+  static const Modifier STATIC = Modifier('STATIC', 31);
 
   /// Indicates that the element does not appear in the source code but was
   /// implicitly created. For example, if a class does not define any
   /// constructors, an implicit zero-argument constructor will be created and it
   /// will be marked as being synthetic.
-  static const Modifier SYNTHETIC = Modifier('SYNTHETIC', 31);
+  static const Modifier SYNTHETIC = Modifier('SYNTHETIC', 32);
 
   /// Indicates that the element was appended to this enclosing element to
   /// simulate temporary the effect of applying augmentation.
-  static const Modifier TEMP_AUGMENTATION = Modifier('TEMP_AUGMENTATION', 32);
+  static const Modifier TEMP_AUGMENTATION = Modifier('TEMP_AUGMENTATION', 33);
 
   static const List<Modifier> values = [
     ABSTRACT,
@@ -5069,6 +5081,7 @@ class Modifier implements Comparable<Modifier> {
     HAS_SINCE_SDK_VERSION_COMPUTED,
     HAS_SINCE_SDK_VERSION_VALUE,
     IMPLICIT_TYPE,
+    INLINE,
     INTERFACE,
     INVOKES_SUPER_SELF,
     LATE,

pkg/analyzer/lib/src/summary2/element_builder.dart

@@ -97,6 +97,7 @@ class ElementBuilder extends ThrowingAstVisitor<void> {
     element.isBase = node.baseKeyword != null;
     element.isInterface = node.interfaceKeyword != null;
     element.isFinal = node.finalKeyword != null;
+    element.isInline = node.inlineKeyword != null;
     element.isMixinClass = node.mixinKeyword != null;
     element.metadata = _buildAnnotations(node.metadata);
     _setCodeRange(element, node);

pkg/analyzer/lib/src/summary2/element_flags.dart

@@ -10,18 +10,20 @@ class ClassElementFlags {
   static const int _isAbstract = 1 << 0;
   static const int _isBase = 1 << 1;
   static const int _isFinal = 1 << 2;
-  static const int _isInterface = 1 << 3;
-  static const int _isMacro = 1 << 4;
-  static const int _isMixinApplication = 1 << 5;
-  static const int _isMixinClass = 1 << 6;
-  static const int _isSealed = 1 << 7;
-  static const int _isSimplyBounded = 1 << 8;
+  static const int _isInline = 1 << 3;
+  static const int _isInterface = 1 << 4;
+  static const int _isMacro = 1 << 5;
+  static const int _isMixinApplication = 1 << 6;
+  static const int _isMixinClass = 1 << 7;
+  static const int _isSealed = 1 << 8;
+  static const int _isSimplyBounded = 1 << 9;
 
   static void read(SummaryDataReader reader, ClassElementImpl element) {
     var byte = reader.readUInt30();
     element.isAbstract = (byte & _isAbstract) != 0;
     element.isBase = (byte & _isBase) != 0;
     element.isFinal = (byte & _isFinal) != 0;
+    element.isInline = (byte & _isInline) != 0;
     element.isInterface = (byte & _isInterface) != 0;
     element.isMacro = (byte & _isMacro) != 0;
     element.isMixinApplication = (byte & _isMixinApplication) != 0;
@@ -35,6 +37,7 @@ class ClassElementFlags {
     result |= element.isAbstract ? _isAbstract : 0;
     result |= element.isBase ? _isBase : 0;
     result |= element.isFinal ? _isFinal : 0;
+    result |= element.isInline ? _isInline : 0;
     result |= element.isInterface ? _isInterface : 0;
     result |= element.isMacro ? _isMacro : 0;
     result |= element.isMixinApplication ? _isMixinApplication : 0;

pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart

@@ -329,6 +329,7 @@ class PubPackageResolutionTest extends ContextResolutionTest {
   List<String> get experiments => [
         EnableString.class_modifiers,
         EnableString.inference_update_2,
+        EnableString.inline_class,
         EnableString.macros,
         EnableString.patterns,
         EnableString.records,

pkg/analyzer/test/src/summary/element_text.dart

@@ -301,6 +301,7 @@ class _ElementWriter {
         _writeIf(e.isBase, 'base ');
         _writeIf(e.isInterface, 'interface ');
         _writeIf(e.isFinal, 'final ');
+        _writeIf(e.isInline, 'inline ');
         _writeIf(e.isMixinClass, 'mixin ');
       }
       _writeIf(!e.isSimplyBounded, 'notSimplyBounded ');

pkg/analyzer/test/src/summary/elements_test.dart

@@ -6574,6 +6574,34 @@ library
 ''');
   }
 
+  test_class_inline() async {
+    var library = await buildLibrary(r'''
+inline class A {
+  final int value;
+  A(this.value);
+}
+''');
+    checkElementText(library, r'''
+library
+  definingUnit
+    classes
+      inline class A @13
+        fields
+          final value @29
+            type: int
+            shouldUseTypeForInitializerInference: true
+        constructors
+          @38
+            parameters
+              requiredPositional final this.value @45
+                type: int
+                field: self::@class::A::@field::value
+        accessors
+          synthetic get value @-1
+            returnType: int
+''');
+  }
+
   test_class_interface() async {
     var library = await buildLibrary('interface class C {}');
     checkElementText(library, r'''