include locally inherited members in suggestions

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;
@@ skipping 85 matching lines @@
 
   @override
   visitCatchClause(CatchClause node) {
     _addParamSuggestion(node.exceptionParameter, node.exceptionType);
     _addParamSuggestion(node.stackTraceParameter, STACKTRACE_TYPE);
     visitNode(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
+    _addClassDeclarationMembers(node);
+    _addInheritedTypeMembers(node);
+    visitNode(node);
+  }
+
+  void _addInheritedTypeMembers(ClassDeclaration node) {
+    ExtendsClause extendsClause = node.extendsClause;
+    if (extendsClause != null) {
+      _addLocalTypeMembers(extendsClause.superclass, node);
+    }
+    ImplementsClause implementsClause = node.implementsClause;
+    if (implementsClause != null) {
+      NodeList<TypeName> interfaces = implementsClause.interfaces;
+      if (interfaces != null) {
+        interfaces.forEach((TypeName type) {
+          _addLocalTypeMembers(type, node);
+        });
+      }
+    }
+    WithClause withClause = node.withClause;
+    if (withClause != null) {
+      NodeList<TypeName> mixinTypes = withClause.mixinTypes;
+      if (mixinTypes != null) {
+        mixinTypes.forEach((TypeName type) {
+          _addLocalTypeMembers(type, node);
+        });
+      }
+    }
+  }
+
+  void _addLocalTypeMembers(TypeName type, ClassDeclaration node) {
+    if (type == null) {
+      return;
+    }
+    Identifier typeId = type.name;
+    if (typeId == null) {
+      return;
+    }
+    String typeName = typeId.name;
+    if (typeName == null || typeName.length == 0) {
+      return;
+    }
+    CompilationUnit unit = node.getAncestor((p) => p is CompilationUnit);
+    if (unit == null) {
+      return;
+    }
+    unit.declarations.forEach((CompilationUnitMember m) {
+      if (m is ClassDeclaration) {
+        SimpleIdentifier id = m.name;
+        if (id != null) {
+          if (id.name == typeName) {
+            _addClassDeclarationMembers(m);
+            _addInheritedTypeMembers(m);
+          }
+        }
+      }
+    });
+  }
+
+  void _addClassDeclarationMembers(ClassDeclaration node) {
     node.members.forEach((ClassMember classMbr) {
       if (classMbr is FieldDeclaration) {
         _addFieldSuggestions(node, classMbr);
       } else if (classMbr is MethodDeclaration) {
         _addMethodSuggestion(node, classMbr);
       }
     });
-    visitNode(node);
   }
 
   @override
   visitCombinator(Combinator node) {
     // Handled by ImportedComputer
   }
 
   @override
   visitCompilationUnit(CompilationUnit node) {
     node.declarations.forEach((Declaration declaration) {
@@ skipping 377 matching lines @@
     if (name == null || name.length <= 0) {
       return DYNAMIC;
     }
     TypeArgumentList typeArgs = type.typeArguments;
     if (typeArgs != null) {
       //TODO (danrubel) include type arguments
     }
     return name;
   }
 }