Issue 3753. Support for @deprecated annotation

compiler/java/com/google/dart/compiler/type/TypeAnalyzer.java

 // Copyright (c) 2012, 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.
 
 package com.google.dart.compiler.type;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Joiner;
 import com.google.common.base.Objects;
 import com.google.common.collect.ArrayListMultimap;
@@ skipping 294 matching lines @@
       return "operator " + operator.getSyntax();
     }
 
     private Type analyzeBinaryOperator(DartNode node, Type lhsType, Token operator,
         DartNode diagnosticNode, DartExpression rhs) {
       Type rhsType = nonVoidTypeOf(rhs);
       String methodName = methodNameForBinaryOperator(operator);
       HasSourceInfo problemTarget = getOperatorHasSourceInfo(node);
       Member member = lookupMember(lhsType, methodName, problemTarget);
       if (member != null) {
-        node.setElement(member.getElement());
+        Element element = member.getElement();
+        node.setElement(element);
         FunctionType methodType = getMethodType(lhsType, member, methodName, diagnosticNode);
+        checkDeprecated(problemTarget, element);
         Type returnType = checkInvocation(Collections.<DartExpression> singletonList(rhs),
             diagnosticNode, methodName, methodType);
         // tweak return type for int/int and int/double operators
         {
           boolean lhsInt = intType.equals(lhsType);
           boolean rhsInt = intType.equals(rhsType);
           boolean lhsDouble = doubleType.equals(lhsType);
           boolean rhsDouble = doubleType.equals(rhsType);
           switch (operator) {
             case ADD:
@@ skipping 894 matching lines @@
       return voidType;
     }
 
     @Override
     public Type visitBreakStatement(DartBreakStatement node) {
       return voidType;
     }
 
     @Override
     public Type visitFunctionObjectInvocation(DartFunctionObjectInvocation node) {
-      node.setElement(functionType.getElement());
+      ClassElement element = functionType.getElement();
+      node.setElement(element);
+      checkDeprecated(node, element);
       return checkInvocation(node, node, null, typeOf(node.getTarget()));
     }
 
     @Override
     public Type visitMethodInvocation(DartMethodInvocation node) {
       DartIdentifier nameNode = node.getFunctionName();
       String name = node.getFunctionNameString();
       Element element = node.getElement();
       if (element != null && (element.getModifiers().isStatic()
                               || Elements.isTopLevel(element))) {
         node.setElement(element);
+        checkDeprecated(nameNode, element);
         return checkInvocation(node, nameNode, name, element.getType());
       }
       DartNode target = node.getTarget();
       Type receiver = nonVoidTypeOf(target);
       Member member = lookupMember(receiver, name, nameNode);
       if (member != null) {
         Element methodElement = member.getElement();
         node.setElement(methodElement);
         if (nameNode != null) {
           nameNode.setElement(methodElement);
         }
       }
+      checkDeprecated(nameNode, nameNode.getElement());
       FunctionType methodType = getMethodType(receiver, member, name, nameNode);
       return checkInvocation(node, nameNode, name, methodType);
     }
 
     @Override
     public Type visitSuperConstructorInvocation(DartSuperConstructorInvocation node) {
       return checkConstructorForwarding(node, node.getElement());
     }
 
     private Type checkConstructorForwarding(DartInvocation node, ConstructorElement element) {
       if (element == null) {
         visit(node.getArguments());
         return voidType;
       } else {
         node.setElement(element);
+        checkDeprecated(node, element);
         checkInvocation(node, node, null, typeAsMemberOf(element, currentClass));
         return voidType;
       }
     }
 
     @Override
     public Type visitCase(DartCase node) {
       node.visitChildren(this);
       return voidType;
     }
@@ skipping 587 matching lines @@
             // The constructor in the interface is resolved to the type parameters declared in
             // the interface, but the constructor body has type parameters resolved to the type
             // parameters in the default class.  This substitution patches up the type variable
             // references used in parameters so they match the concrete class.
             substParams = ((ClassElement)constructorElement.getEnclosingElement()).getType().getArguments();
           } else {
             substParams = ifaceType.getElement().getTypeParameters();
           }
           List<Type> arguments = ifaceType.getArguments();
           ftype = (FunctionType) ftype.subst(arguments, substParams);
-          checkInvocation(node, node, null, ftype);
+          checkDeprecated(getConstructorNameNode(node), constructorElement);
+          checkInvocation(node, node, constructorElement.getName(), ftype);
         }
       }
       type.getClass(); // quick null check
       return type;
     }
 
     /**
      * @param cls the {@link ClassElement}  which has unimplemented members.
      * @param unimplementedMembers the unimplemented members {@link Element}s.
      * @return the {@link StringBuilder} with message about unimplemented members.
@@ skipping 86 matching lines @@
         return dynamicType;
       }
       element = member.getElement();
       node.setElement(element);
       Modifiers modifiers = element.getModifiers();
       if (modifiers.isStatic()) {
         return typeError(node.getName(),
                          TypeErrorCode.STATIC_MEMBER_ACCESSED_THROUGH_INSTANCE,
                          name, element.getName());
       }
+      // @deprecated
+      if (element != null && element.getMetadata().isDeprecated()) {
+        onError(node.getName(), TypeErrorCode.DEPRECATED_ELEMENT, name);
+      }
+      // analyze Element
       switch (element.getKind()) {
         case DYNAMIC:
           return dynamicType;
         case CONSTRUCTOR:
           return typeError(node.getName(), TypeErrorCode.MEMBER_IS_A_CONSTRUCTOR,
                            name, element.getName());
 
         case METHOD:
           return member.getType();
 
@@ skipping 174 matching lines @@
           // bit operations, we currently allow them to be used
           // if the left-hand-side is of type num.
           // TODO(karlklose) find a clean solution, i.e., without a special case for num.
           if (type.equals(numType)) {
             return intType;
           } else {
             String name = methodNameForUnaryOperator(node, operator);
             HasSourceInfo problemTarget = getOperatorHasSourceInfo(node);
             Member member = lookupMember(type, name, problemTarget);
             if (member != null) {
-              node.setElement(member.getElement());
+              Element element = member.getElement();
+              node.setElement(element);
               FunctionType methodType = getMethodType(type, member, name, node);
+              checkDeprecated(problemTarget, element);
               return checkInvocation(Collections.<DartExpression>emptyList(), node, name, methodType);
             } else {
               return dynamicType;
             }
           }
         case NOT:
           checkAssignable(boolType, expression);
           return boolType;
         case SUB:
         case INC:
@@ skipping 69 matching lines @@
           if (type instanceof InterfaceType) {
             InterfaceType interfaceType = (InterfaceType) type;
             Element callElement = interfaceType.getElement().lookupLocalElement("call");
             if (ElementKind.of(callElement) == ElementKind.METHOD) {
               node.setElement(callElement);
               type = typeAsMemberOf(callElement, interfaceType);
             }
           }
           break;
       }
+      checkDeprecated(target, element);
       return checkInvocation(node, target, name, type);
     }
 
+    /**
+     * Report warning if given {@link Element} is deprecated.
+     */
+    private void checkDeprecated(HasSourceInfo nameNode, Element element) {
+      if (element != null && element.getMetadata().isDeprecated()) {
+        onError(nameNode, TypeErrorCode.DEPRECATED_ELEMENT, element);
+      }
+    }
+
     private Type checkInvocation(DartInvocation node, DartNode diagnosticNode, String name,
         Type type) {
       List<DartExpression> argumentNodes = node.getArguments();
       return checkInvocation(argumentNodes, diagnosticNode, name, type);
     }
 
-    private Type checkInvocation(List<DartExpression> argumentNodes,
-        DartNode diagnosticNode, String name, Type type) {
+    private Type checkInvocation(List<DartExpression> argumentNodes, DartNode diagnosticNode,
+        String name, Type type) {
       // Prepare argument types.
       List<Type> argumentTypes = Lists.newArrayListWithCapacity(argumentNodes.size());
       for (DartExpression argumentNode : argumentNodes) {
         Type argumentType = getInvocationArgumentType(argumentNode);
         argumentTypes.add(argumentType);
       }
       // Check that argument types are compatible with type of invoked object.
       try {
         switch (TypeKind.of(type)) {
           case FUNCTION_ALIAS:
@@ skipping 241 matching lines @@
       }
       // prevent recursion
       if (visited.contains(current)) {
         return false;
       }
       visited.add(current);
       // check type of "current" function type alias
       return hasFunctionTypeAliasReference(visited, target, current);
     }
 
+    /**
+     * @return the {@link DartIdentifier} corresponding to the name of constructor.
+     */
+    public static DartIdentifier getConstructorNameNode(DartNewExpression node) {
+      DartNode constructor = node.getConstructor();
+      return getConstructorNameNode(constructor);
+    }
+    
+    /**
+     * @return the {@link DartIdentifier} corresponding to the name of constructor.
+     */
+    public static DartIdentifier getConstructorNameNode(DartNode constructor) {
+      if (constructor instanceof DartPropertyAccess) {
+        return ((DartPropertyAccess) constructor).getName();
+      } else if (constructor instanceof DartTypeNode) {
+        return getConstructorNameNode(((DartTypeNode) constructor).getIdentifier());
+      } else {
+        return (DartIdentifier) constructor;
+      }
+    }
+
     @Override
     public Type visitIntegerLiteral(DartIntegerLiteral node) {
       return typeOfLiteral(node);
     }
 
     @Override
     public Type visitStringLiteral(DartStringLiteral node) {
       return typeOfLiteral(node);
     }
 
@@ skipping 309 matching lines @@
         for (VariableElement v : parameters) {
           if (v.isNamed()) {
             named.add(v);
           }
         }
         return named;
       }
     }
   }
 }