Add error checking for the immutable annotation (issue 27750)

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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 90 matching lines @@
       this._currentLibrary, this._manager,
       {TypeSystem typeSystem})
       : _nullType = typeProvider.nullType,
         _futureNullType = typeProvider.futureNullType,
         _typeSystem = typeSystem ?? new TypeSystemImpl(typeProvider) {
     inDeprecatedMember = _currentLibrary.isDeprecated;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
-    if (resolutionMap.elementAnnotationForAnnotation(node)?.isFactory == true) {
+    ElementAnnotation element =
+        resolutionMap.elementAnnotationForAnnotation(node);
+    if (element?.isFactory == true) {
       AstNode parent = node.parent;
       if (parent is MethodDeclaration) {
         _checkForInvalidFactory(parent);
       } else {
         _errorReporter
             .reportErrorForNode(HintCode.INVALID_FACTORY_ANNOTATION, node, []);
       }
+    } else if (element?.isImmutable == true) {
+      AstNode parent = node.parent;
+      if (parent is! ClassDeclaration) {
+        _errorReporter.reportErrorForNode(
+            HintCode.INVALID_IMMUTABLE_ANNOTATION, node, []);
+      }
     }
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
     for (Expression argument in node.arguments) {
       ParameterElement parameter = argument.bestParameterElement;
       if (parameter?.parameterKind == ParameterKind.POSITIONAL) {
         _checkForDeprecatedMemberUse(parameter, argument);
@@ skipping 45 matching lines @@
     ClassElementImpl outerClass = _enclosingClass;
     bool wasInDeprecatedMember = inDeprecatedMember;
     ClassElement element = AbstractClassElementImpl.getImpl(node.element);
     if (element != null && element.isDeprecated) {
       inDeprecatedMember = true;
     }
     try {
       _enclosingClass = element;
       // Commented out until we decide that we want this hint in the analyzer
       //    checkForOverrideEqualsButNotHashCode(node);
+      _checkForImmutable(node);
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
       inDeprecatedMember = wasInDeprecatedMember;
     }
   }
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     _checkForPossibleNullCondition(node.condition);
@@ skipping 528 matching lines @@
             grandParent.argumentList.arguments.isEmpty) {
           _errorReporter.reportErrorForNode(
               HintCode.DIVISION_OPTIMIZATION, grandParent);
           return true;
         }
       }
     }
     return false;
   }
 
+  void _checkForImmutable(ClassDeclaration node) {
+    /**
+     * Return `true` if the given class [element] is annotated with the
+     * `@immutable` annotation.
+     */
+    bool isImmutable(ClassElement element) {
+      for (ElementAnnotation annotation in element.metadata) {
+        if (annotation.isImmutable) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Return `true` if the given class [element] or any superclass of it is
+     * annotated with the `@immutable` annotation.
+     */
+    bool isOrInheritsImmutable(
+        ClassElement element, HashSet<ClassElement> visited) {
+      if (visited.add(element)) {
+        if (isImmutable(element)) {
+          return true;
+        }
+        for (InterfaceType interface in element.mixins) {
+          if (isOrInheritsImmutable(interface.element, visited)) {
+            return true;
+          }
+        }
+        for (InterfaceType mixin in element.interfaces) {
+          if (isOrInheritsImmutable(mixin.element, visited)) {
+            return true;
+          }
+        }
+        if (element.supertype != null) {
+          return isOrInheritsImmutable(element.supertype.element, visited);
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Return `true` if the given class [element] defines a non-final field.
+     */
+    bool hasNonFinalField(ClassElement element) {
+      for (FieldElement field in element.fields) {
+        if (!field.isSynthetic && !field.isFinal) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Return `true` if the given class [element] defines or inherits a
+     * non-final field.
+     */
+    bool hasOrInheritsNonFinalField(
+        ClassElement element, HashSet<ClassElement> visited) {
+      if (visited.add(element)) {
+        if (hasNonFinalField(element)) {
+          return true;
+        }
+        for (InterfaceType mixin in element.mixins) {
+          if (hasNonFinalField(mixin.element)) {
+            return true;
+          }
+        }
+        if (element.supertype != null) {
+          return hasOrInheritsNonFinalField(element.supertype.element, visited);
+        }
+      }
+      return false;
+    }
+
+    ClassElement element = node.element;
+    if (isOrInheritsImmutable(element, new HashSet<ClassElement>()) &&
+        hasOrInheritsNonFinalField(element, new HashSet<ClassElement>())) {
+      _errorReporter.reportErrorForNode(HintCode.MUST_BE_IMMUTABLE, node.name);
+    }
+  }
+
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
    * This method corresponds to ErrorVerifier.checkForInvalidAssignment.
    *
    * @param lhs the left hand side expression
    * @param rhs the right hand side expression
    * @return `true` if and only if an error code is generated on the passed node
    * See [HintCode.INVALID_ASSIGNMENT].
    */
@@ skipping 10063 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }