show only type names in is expression RHS

pkg/analysis_server/lib/src/services/completion/local_computer.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 services.completion.computer.dart.local;
 
 import 'dart:async';
 
-import 'package:analysis_server/src/protocol.dart' as protocol show Element, ElementKind;
+import 'package:analysis_server/src/protocol.dart' as protocol show Element,
+    ElementKind;
 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 import 'package:analysis_server/src/services/completion/dart_completion_manager.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 
 /**
  * A computer for calculating `completion.getSuggestions` request results
  * for the local library in which the completion is requested.
  */
 class LocalComputer extends DartCompletionComputer {
@@ skipping 29 matching lines @@
 
   static final TypeName NO_RETURN_TYPE = new TypeName(
       new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)),
       null);
 
   static final TypeName STACKTRACE_TYPE = new TypeName(
       new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, 'StackTrace', 0)),
       null);
 
   final DartCompletionRequest request;
+  bool typesOnly = false;
 
   _LocalVisitor(this.request);
 
   @override
   visitBlock(Block node) {
     node.statements.forEach((Statement stmt) {
       if (stmt.offset < request.offset) {
         if (stmt is LabeledStatement) {
           stmt.labels.forEach((Label label) {
 //            _addSuggestion(label.label, CompletionSuggestionKind.LABEL);
           });
         } else if (stmt is VariableDeclarationStatement) {
           var varList = stmt.variables;
           if (varList != null) {
             varList.variables.forEach((VariableDeclaration varDecl) {
               if (varDecl.end < request.offset) {
                 _addLocalVarSuggestion(varDecl.name, varList.type);
               }
             });
           }
         }
       }
     });
     visitNode(node);
   }
 
   @override
+  visitCascadeExpression(CascadeExpression node) {
+    Expression target = node.target;
+    // This computer handles the expression
+    // while InvocationComputer handles the cascade selector
+    if (target != null && request.offset <= target.end) {
+      visitNode(node);
+    }
+  }
+
+  @override
   visitCatchClause(CatchClause node) {
     _addParamSuggestion(node.exceptionParameter, node.exceptionType);
-    CompletionSuggestion suggestion =
-        _addParamSuggestion(node.stackTraceParameter, STACKTRACE_TYPE);
+    _addParamSuggestion(node.stackTraceParameter, STACKTRACE_TYPE);
     visitNode(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     node.members.forEach((ClassMember classMbr) {
       if (classMbr is FieldDeclaration) {
         _addFieldSuggestions(node, classMbr);
       } else if (classMbr is MethodDeclaration) {
         _addMethodSuggestion(node, classMbr);
@@ skipping 52 matching lines @@
       type = loopVar.type;
     } else {
       id = node.identifier;
       type = null;
     }
     _addLocalVarSuggestion(id, type);
     visitNode(node);
   }
 
   @override
-  visitPrefixedIdentifier(PrefixedIdentifier node) {
-    // InvocationComputer adds suggestions for prefixed elements
-    // but this computer adds suggestions for the prefix itself
-    SimpleIdentifier prefix = node.prefix;
-    if (prefix == null || request.offset <= prefix.end) {
-      visitNode(node);
-    }
-  }
-
-  @override
   visitForStatement(ForStatement node) {
     var varList = node.variables;
     if (varList != null) {
       varList.variables.forEach((VariableDeclaration varDecl) {
         _addLocalVarSuggestion(varDecl.name, varList.type);
       });
     }
     visitNode(node);
   }
 
@@ skipping 15 matching lines @@
     _addParamListSuggestions(node.parameters);
     visitNode(node);
   }
 
   @override
   visitNode(AstNode node) {
     node.parent.accept(this);
   }
 
   @override
-  visitCascadeExpression(CascadeExpression node) {
-    Expression target = node.target;
-    // This computer handles the expression
-    // while InvocationComputer handles the cascade selector
-    if (target != null && request.offset <= target.end) {
+  visitPrefixedIdentifier(PrefixedIdentifier node) {
+    // InvocationComputer adds suggestions for prefixed elements
+    // but this computer adds suggestions for the prefix itself
+    SimpleIdentifier prefix = node.prefix;
+    if (prefix == null || request.offset <= prefix.end) {
       visitNode(node);
     }
   }
 
   @override
+  visitTypeName(TypeName node) {
+    // If suggesting completions within a TypeName node
+    // then limit suggestions to only types
+    typesOnly = true;
+    return visitNode(node);
+  }
+
+  @override
   visitVariableDeclaration(VariableDeclaration node) {
     // Do not add suggestions if editing the name in a var declaration
     SimpleIdentifier name = node.name;
     if (name == null ||
         name.offset < request.offset ||
         request.offset > name.end) {
       visitNode(node);
     }
   }
 
   void _addClassSuggestion(ClassDeclaration declaration) {
     CompletionSuggestion suggestion =
         _addSuggestion(declaration.name, CompletionSuggestionKind.CLASS, null, null);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.CLASS,
           declaration.name,
           NO_RETURN_TYPE,
           declaration.isAbstract,
           _isDeprecated(declaration.metadata));
     }
   }
 
   void _addFieldSuggestions(ClassDeclaration node, FieldDeclaration fieldDecl) {
+    if (typesOnly) {
+      return;
+    }
     bool isDeprecated = _isDeprecated(fieldDecl.metadata);
     fieldDecl.fields.variables.forEach((VariableDeclaration varDecl) {
       CompletionSuggestion suggestion = _addSuggestion(
           varDecl.name,
           CompletionSuggestionKind.GETTER,
           fieldDecl.fields.type,
           node);
       if (suggestion != null) {
         suggestion.element = _createElement(
             protocol.ElementKind.GETTER,
             varDecl.name,
             fieldDecl.fields.type,
             false,
             isDeprecated || _isDeprecated(varDecl.metadata));
       }
     });
   }
 
   void _addFunctionSuggestion(FunctionDeclaration declaration) {
+    if (typesOnly) {
+      return;
+    }
     CompletionSuggestion suggestion = _addSuggestion(
         declaration.name,
         CompletionSuggestionKind.FUNCTION,
         declaration.returnType,
         null);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.FUNCTION,
           declaration.name,
           declaration.returnType,
           false,
           _isDeprecated(declaration.metadata));
     }
   }
 
   void _addLocalVarSuggestion(SimpleIdentifier id, TypeName returnType) {
+    if (typesOnly) {
+      return;
+    }
     CompletionSuggestion suggestion =
         _addSuggestion(id, CompletionSuggestionKind.LOCAL_VARIABLE, returnType, null);
     if (suggestion != null) {
       suggestion.element = _createElement(
           protocol.ElementKind.LOCAL_VARIABLE,
           id,
           returnType,
           false,
           false);
     }
   }
 
   void _addMethodSuggestion(ClassDeclaration node, MethodDeclaration classMbr) {
+    if (typesOnly) {
+      return;
+    }
     protocol.ElementKind kind;
     CompletionSuggestionKind csKind;
     if (classMbr.isGetter) {
       kind = protocol.ElementKind.GETTER;
       csKind = CompletionSuggestionKind.GETTER;
     } else if (classMbr.isSetter) {
       kind = protocol.ElementKind.SETTER;
       csKind = CompletionSuggestionKind.SETTER;
     } else {
       kind = protocol.ElementKind.METHOD;
       csKind = CompletionSuggestionKind.METHOD;
     }
     CompletionSuggestion suggestion =
         _addSuggestion(classMbr.name, csKind, classMbr.returnType, node);
     suggestion.element = _createElement(
         kind,
         classMbr.name,
         classMbr.returnType,
         classMbr.isAbstract,
         _isDeprecated(classMbr.metadata));
   }
 
   void _addParamListSuggestions(FormalParameterList paramList) {
+    if (typesOnly) {
+      return;
+    }
     if (paramList != null) {
       paramList.parameters.forEach((FormalParameter param) {
         NormalFormalParameter normalParam;
         if (param is DefaultFormalParameter) {
           normalParam = param.parameter;
         } else if (param is NormalFormalParameter) {
           normalParam = param;
         }
         TypeName type = null;
         if (normalParam is FieldFormalParameter) {
           type = normalParam.type;
         } else if (normalParam is FunctionTypedFormalParameter) {
           type = normalParam.returnType;
         } else if (normalParam is SimpleFormalParameter) {
           type = normalParam.type;
         }
         _addParamSuggestion(param.identifier, type);
       });
     }
   }
 
-  CompletionSuggestion _addParamSuggestion(SimpleIdentifier identifier,
-      TypeName type) {
+  void _addParamSuggestion(SimpleIdentifier identifier, TypeName type) {
+    if (typesOnly) {
+      return;
+    }
     CompletionSuggestion suggestion =
         _addSuggestion(identifier, CompletionSuggestionKind.PARAMETER, type, null);
     if (suggestion != null) {
       suggestion.element =
           _createElement(protocol.ElementKind.PARAMETER, identifier, type, false, false);
     }
-    return suggestion;
   }
 
   CompletionSuggestion _addSuggestion(SimpleIdentifier id,
       CompletionSuggestionKind kind, TypeName typeName, ClassDeclaration classDecl) {
     if (id != null) {
       String completion = id.name;
       if (completion != null && completion.length > 0) {
         CompletionSuggestion suggestion = new CompletionSuggestion(
             kind,
             CompletionRelevance.DEFAULT,
@@ skipping 21 matching lines @@
           }
         }
         request.suggestions.add(suggestion);
         return suggestion;
       }
     }
     return null;
   }
 
   void _addTopLevelVarSuggestions(VariableDeclarationList varList) {
+    if (typesOnly) {
+      return;
+    }
     if (varList != null) {
       bool isDeprecated = _isDeprecated(varList.metadata);
       varList.variables.forEach((VariableDeclaration varDecl) {
         CompletionSuggestion suggestion = _addSuggestion(
             varDecl.name,
             CompletionSuggestionKind.TOP_LEVEL_VARIABLE,
             varList.type,
             null);
         if (suggestion != null) {
           suggestion.element = _createElement(
@@ skipping 50 matching lines @@
     if (name == null || name.length <= 0) {
       return DYNAMIC;
     }
     TypeArgumentList typeArgs = type.typeArguments;
     if (typeArgs != null) {
       //TODO (danrubel) include type arguments
     }
     return name;
   }
 }