diff --git a/pkg/analysis_server/lib/src/computer/computer_highlights.dart b/pkg/analysis_server/lib/src/computer/computer_highlights.dart
new file mode 100644
index 0000000..06a3db4
--- /dev/null
+++ b/pkg/analysis_server/lib/src/computer/computer_highlights.dart
@@ -0,0 +1,517 @@
+// 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 computer.highlights;
+
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/scanner.dart';
+
+
+/**
+ * A computer for [HighlightRegion]s in a Dart [CompilationUnit].
+ */
+class DartUnitHighlightsComputer {
+  final CompilationUnit _unit;
+
+  final List<Map<String, Object>> _regions = <Map<String, Object>>[];
+
+  DartUnitHighlightsComputer(this._unit);
+
+  /**
+   * Returns the computed highlight regions, not `null`.
+   */
+  List<Map<String, Object>> compute() {
+    _unit.accept(new _DartUnitHighlightsComputerVisitor(this));
+    return _regions;
+  }
+
+  void _addIdentifierRegion(SimpleIdentifier node) {
+    if (_addIdentifierRegion_keyword(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_class(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_constructor(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_dynamicType(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_getterSetterDeclaration(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_field(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_function(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_functionTypeAlias(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_importPrefix(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_localVariable(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_method(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_parameter(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_topLevelVariable(node)) {
+      return;
+    }
+    if (_addIdentifierRegion_typeParameter(node)) {
+      return;
+    }
+    _addRegion_node(node, HighlightType.IDENTIFIER_DEFAULT);
+  }
+
+  void _addIdentifierRegion_annotation(Annotation node) {
+    ArgumentList arguments = node.arguments;
+    if (arguments == null) {
+      _addRegion_node(node, HighlightType.ANNOTATION);
+    } else {
+      _addRegion_nodeStart_tokenEnd(node, arguments.beginToken, HighlightType.ANNOTATION);
+      _addRegion_token(arguments.endToken, HighlightType.ANNOTATION);
+    }
+  }
+
+  bool _addIdentifierRegion_class(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! ClassElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.CLASS);
+  }
+
+  bool _addIdentifierRegion_constructor(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! ConstructorElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.CONSTRUCTOR);
+  }
+
+  bool _addIdentifierRegion_dynamicType(SimpleIdentifier node) {
+    // should be variable
+    Element element = node.staticElement;
+    if (element is! VariableElement) {
+      return false;
+    }
+    // has propagated type
+    if (node.propagatedType != null) {
+      return false;
+    }
+    // has dynamic static type
+    DartType staticType = node.staticType;
+    if (staticType == null || !staticType.isDynamic) {
+      return false;
+    }
+    // OK
+    return _addRegion_node(node, HighlightType.DYNAMIC_TYPE);
+  }
+
+  bool _addIdentifierRegion_field(SimpleIdentifier node) {
+    Element element = node.bestElement;
+    if (element is FieldFormalParameterElement) {
+      element = (element as FieldFormalParameterElement).field;
+    }
+    if (element is FieldElement) {
+      if ((element as FieldElement).isStatic) {
+        return _addRegion_node(node, HighlightType.FIELD_STATIC);
+      } else {
+        return _addRegion_node(node, HighlightType.FIELD);
+      }
+    }
+    if (element is PropertyAccessorElement) {
+      if ((element as PropertyAccessorElement).isStatic) {
+        return _addRegion_node(node, HighlightType.FIELD_STATIC);
+      } else {
+        return _addRegion_node(node, HighlightType.FIELD);
+      }
+    }
+    return false;
+  }
+
+  bool _addIdentifierRegion_function(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! FunctionElement) {
+      return false;
+    }
+    HighlightType type;
+    if (node.inDeclarationContext()) {
+      type = HighlightType.FUNCTION_DECLARATION;
+    } else {
+      type = HighlightType.FUNCTION;
+    }
+    return _addRegion_node(node, type);
+  }
+
+  bool _addIdentifierRegion_functionTypeAlias(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! FunctionTypeAliasElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.FUNCTION_TYPE_ALIAS);
+  }
+
+  bool _addIdentifierRegion_getterSetterDeclaration(SimpleIdentifier node) {
+    // should be declaration
+    AstNode parent = node.parent;
+    if (!(parent is MethodDeclaration || parent is FunctionDeclaration)) {
+      return false;
+    }
+    // should be property accessor
+    Element element = node.staticElement;
+    if (element is! PropertyAccessorElement) {
+      return false;
+    }
+    // getter or setter
+    PropertyAccessorElement propertyAccessorElement = element as PropertyAccessorElement;
+    if (propertyAccessorElement.isGetter) {
+      return _addRegion_node(node, HighlightType.GETTER_DECLARATION);
+    } else {
+      return _addRegion_node(node, HighlightType.SETTER_DECLARATION);
+    }
+  }
+
+  bool _addIdentifierRegion_importPrefix(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! PrefixElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.IMPORT_PREFIX);
+  }
+
+  bool _addIdentifierRegion_keyword(SimpleIdentifier node) {
+    String name = node.name;
+    if (name == "void") {
+      return _addRegion_node(node, HighlightType.KEYWORD);
+    }
+    return false;
+  }
+
+  bool _addIdentifierRegion_localVariable(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! LocalVariableElement) {
+      return false;
+    }
+    // OK
+    HighlightType type;
+    if (node.inDeclarationContext()) {
+      type = HighlightType.LOCAL_VARIABLE_DECLARATION;
+    } else {
+      type = HighlightType.LOCAL_VARIABLE;
+    }
+    return _addRegion_node(node, type);
+  }
+
+  bool _addIdentifierRegion_method(SimpleIdentifier node) {
+    Element element = node.bestElement;
+    if (element is! MethodElement) {
+      return false;
+    }
+    MethodElement methodElement = element as MethodElement;
+    bool isStatic = methodElement.isStatic;
+    // OK
+    HighlightType type;
+    if (node.inDeclarationContext()) {
+      if (isStatic) {
+        type = HighlightType.METHOD_DECLARATION_STATIC;
+      } else {
+        type = HighlightType.METHOD_DECLARATION;
+      }
+    } else {
+      if (isStatic) {
+        type = HighlightType.METHOD_STATIC;
+      } else {
+        type = HighlightType.METHOD;
+      }
+    }
+    return _addRegion_node(node, type);
+  }
+
+  bool _addIdentifierRegion_parameter(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! ParameterElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.PARAMETER);
+  }
+
+  bool _addIdentifierRegion_topLevelVariable(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! TopLevelVariableElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.TOP_LEVEL_VARIABLE);
+  }
+
+  bool _addIdentifierRegion_typeParameter(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element is! TypeParameterElement) {
+      return false;
+    }
+    return _addRegion_node(node, HighlightType.TYPE_PARAMETER);
+  }
+
+  void _addRegion(int offset, int length, HighlightType type) {
+    _regions.add({'offset': offset, 'length': length, 'type': type.name});
+  }
+
+  bool _addRegion_node(AstNode node, HighlightType type) {
+    int offset = node.offset;
+    int length = node.length;
+    _addRegion(offset, length, type);
+    return true;
+  }
+
+  void _addRegion_nodeStart_tokenEnd(AstNode a, Token b, HighlightType type) {
+    int offset = a.offset;
+    int end = b.end;
+    _addRegion(offset, end - offset, type);
+  }
+
+  void _addRegion_token(Token token, HighlightType type) {
+    if (token != null) {
+      int offset = token.offset;
+      int length = token.length;
+      _addRegion(offset, length, type);
+    }
+  }
+
+  void _addRegion_tokenStart_tokenEnd(Token a, Token b, HighlightType type) {
+    int offset = a.offset;
+    int end = b.end;
+    _addRegion(offset, end - offset, type);
+  }
+}
+
+
+/**
+ * An AST visitor for [DartUnitHighlightsComputer].
+ */
+class _DartUnitHighlightsComputerVisitor extends RecursiveAstVisitor<Object> {
+  final DartUnitHighlightsComputer computer;
+
+  _DartUnitHighlightsComputerVisitor(this.computer);
+
+  @override
+  Object visitAnnotation(Annotation node) {
+    computer._addIdentifierRegion_annotation(node);
+    return super.visitAnnotation(node);
+  }
+
+  @override
+  Object visitAsExpression(AsExpression node) {
+    computer._addRegion_token(node.asOperator, HighlightType.BUILT_IN);
+    return super.visitAsExpression(node);
+  }
+
+  @override
+  Object visitBooleanLiteral(BooleanLiteral node) {
+    computer._addRegion_node(node, HighlightType.LITERAL_BOOLEAN);
+    return super.visitBooleanLiteral(node);
+  }
+
+  @override
+  Object visitCatchClause(CatchClause node) {
+    computer._addRegion_token(node.onKeyword, HighlightType.BUILT_IN);
+    return super.visitCatchClause(node);
+  }
+
+  @override
+  Object visitClassDeclaration(ClassDeclaration node) {
+    computer._addRegion_token(node.abstractKeyword, HighlightType.BUILT_IN);
+    return super.visitClassDeclaration(node);
+  }
+
+  @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    computer._addRegion_token(node.externalKeyword, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.factoryKeyword, HighlightType.BUILT_IN);
+    return super.visitConstructorDeclaration(node);
+  }
+
+  @override
+  Object visitDoubleLiteral(DoubleLiteral node) {
+    computer._addRegion_node(node, HighlightType.LITERAL_DOUBLE);
+    return super.visitDoubleLiteral(node);
+  }
+
+  @override
+  Object visitExportDirective(ExportDirective node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitExportDirective(node);
+  }
+
+  @override
+  Object visitFieldDeclaration(FieldDeclaration node) {
+    computer._addRegion_token(node.staticKeyword, HighlightType.BUILT_IN);
+    return super.visitFieldDeclaration(node);
+  }
+
+  @override
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    computer._addRegion_token(node.externalKeyword, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.propertyKeyword, HighlightType.BUILT_IN);
+    return super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitFunctionTypeAlias(node);
+  }
+
+  @override
+  Object visitHideCombinator(HideCombinator node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitHideCombinator(node);
+  }
+
+  @override
+  Object visitImplementsClause(ImplementsClause node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitImplementsClause(node);
+  }
+
+  @override
+  Object visitImportDirective(ImportDirective node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.deferredToken, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.asToken, HighlightType.BUILT_IN);
+    return super.visitImportDirective(node);
+  }
+
+  @override
+  Object visitIntegerLiteral(IntegerLiteral node) {
+    computer._addRegion_node(node, HighlightType.LITERAL_INTEGER);
+    return super.visitIntegerLiteral(node);
+  }
+
+  @override
+  Object visitLibraryDirective(LibraryDirective node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitLibraryDirective(node);
+  }
+
+  @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    computer._addRegion_token(node.externalKeyword, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.modifierKeyword, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.operatorKeyword, HighlightType.BUILT_IN);
+    computer._addRegion_token(node.propertyKeyword, HighlightType.BUILT_IN);
+    return super.visitMethodDeclaration(node);
+  }
+
+  @override
+  Object visitNativeClause(NativeClause node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitNativeClause(node);
+  }
+
+  @override
+  Object visitNativeFunctionBody(NativeFunctionBody node) {
+    computer._addRegion_token(node.nativeToken, HighlightType.BUILT_IN);
+    return super.visitNativeFunctionBody(node);
+  }
+
+  @override
+  Object visitPartDirective(PartDirective node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitPartDirective(node);
+  }
+
+  @override
+  Object visitPartOfDirective(PartOfDirective node) {
+    computer._addRegion_tokenStart_tokenEnd(node.partToken, node.ofToken, HighlightType.BUILT_IN);
+    return super.visitPartOfDirective(node);
+  }
+
+  @override
+  Object visitShowCombinator(ShowCombinator node) {
+    computer._addRegion_token(node.keyword, HighlightType.BUILT_IN);
+    return super.visitShowCombinator(node);
+  }
+
+  @override
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    computer._addIdentifierRegion(node);
+    return super.visitSimpleIdentifier(node);
+  }
+
+  @override
+  Object visitSimpleStringLiteral(SimpleStringLiteral node) {
+    computer._addRegion_node(node, HighlightType.LITERAL_STRING);
+    return super.visitSimpleStringLiteral(node);
+  }
+
+  @override
+  Object visitTypeName(TypeName node) {
+    DartType type = node.type;
+    if (type != null) {
+      if (type.isDynamic && node.name.name == "dynamic") {
+        computer._addRegion_node(node, HighlightType.TYPE_NAME_DYNAMIC);
+        return null;
+      }
+    }
+    return super.visitTypeName(node);
+  }
+}
+
+
+/**
+ * Highlighting kinds constants.
+ */
+class HighlightType {
+  static const HighlightType ANNOTATION = const HighlightType('ANNOTATION');
+  static const HighlightType BUILT_IN = const HighlightType('BUILT_IN');
+  static const HighlightType CLASS = const HighlightType('CLASS');
+  static const HighlightType COMMENT_BLOCK = const HighlightType('COMMENT_BLOCK');
+  static const HighlightType COMMENT_DOCUMENTATION = const HighlightType('COMMENT_DOCUMENTATION');
+  static const HighlightType COMMENT_END_OF_LINE = const HighlightType('COMMENT_END_OF_LINE');
+  static const HighlightType CONSTRUCTOR = const HighlightType('CONSTRUCTOR');
+  static const HighlightType DIRECTIVE = const HighlightType('DIRECTIVE');
+  static const HighlightType DYNAMIC_TYPE = const HighlightType('DYNAMIC_TYPE');
+  static const HighlightType FIELD = const HighlightType('FIELD');
+  static const HighlightType FIELD_STATIC = const HighlightType('FIELD_STATIC');
+  static const HighlightType FUNCTION_DECLARATION = const HighlightType('FUNCTION_DECLARATION');
+  static const HighlightType FUNCTION = const HighlightType('FUNCTION');
+  static const HighlightType FUNCTION_TYPE_ALIAS = const HighlightType('FUNCTION_TYPE_ALIAS');
+  static const HighlightType GETTER_DECLARATION = const HighlightType('GETTER_DECLARATION');
+  static const HighlightType KEYWORD = const HighlightType('KEYWORD');
+  static const HighlightType IDENTIFIER_DEFAULT = const HighlightType('IDENTIFIER_DEFAULT');
+  static const HighlightType IMPORT_PREFIX = const HighlightType('IMPORT_PREFIX');
+  static const HighlightType LITERAL_BOOLEAN = const HighlightType('LITERAL_BOOLEAN');
+  static const HighlightType LITERAL_DOUBLE = const HighlightType('LITERAL_DOUBLE');
+  static const HighlightType LITERAL_INTEGER = const HighlightType('LITERAL_INTEGER');
+  static const HighlightType LITERAL_LIST = const HighlightType('LITERAL_LIST');
+  static const HighlightType LITERAL_MAP = const HighlightType('LITERAL_MAP');
+  static const HighlightType LITERAL_STRING = const HighlightType('LITERAL_STRING');
+  static const HighlightType LOCAL_VARIABLE_DECLARATION = const HighlightType('LOCAL_VARIABLE_DECLARATION');
+  static const HighlightType LOCAL_VARIABLE = const HighlightType('LOCAL_VARIABLE');
+  static const HighlightType METHOD_DECLARATION = const HighlightType('METHOD_DECLARATION');
+  static const HighlightType METHOD_DECLARATION_STATIC = const HighlightType('METHOD_DECLARATION_STATIC');
+  static const HighlightType METHOD = const HighlightType('METHOD');
+  static const HighlightType METHOD_STATIC = const HighlightType('METHOD_STATIC');
+  static const HighlightType PARAMETER = const HighlightType('PARAMETER');
+  static const HighlightType SETTER_DECLARATION = const HighlightType('SETTER_DECLARATION');
+  static const HighlightType TOP_LEVEL_VARIABLE = const HighlightType('TOP_LEVEL_VARIABLE');
+  static const HighlightType TYPE_NAME_DYNAMIC = const HighlightType('TYPE_NAME_DYNAMIC');
+  static const HighlightType TYPE_PARAMETER = const HighlightType('TYPE_PARAMETER');
+
+  final String name;
+
+  @override
+  String toString() => name;
+
+  const HighlightType(this.name);
+}
diff --git a/pkg/analysis_server/lib/src/computer/computer_navigation.dart b/pkg/analysis_server/lib/src/computer/computer_navigation.dart
new file mode 100644
index 0000000..d329425
--- /dev/null
+++ b/pkg/analysis_server/lib/src/computer/computer_navigation.dart
@@ -0,0 +1,208 @@
+// 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 computer.navigation;
+
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/source.dart';
+
+
+/**
+ * A computer for navigation regions in a Dart [CompilationUnit].
+ */
+class DartUnitNavigationComputer {
+  final CompilationUnit _unit;
+
+  List<Map<String, Object>> _regions = <Map<String, Object>>[];
+
+  DartUnitNavigationComputer(this._unit);
+
+  /**
+   * Returns the computed navigation regions, not `null`.
+   */
+  List<Map<String, Object>> compute() {
+    _unit.accept(new _DartUnitNavigationComputerVisitor(this));
+    return new List.from(_regions);
+  }
+
+  void _addRegion(int offset, int length, Element element) {
+    Map<String, Object> target = _createTarget(element);
+    if (target == null) {
+      return;
+    }
+    _regions.add({
+      'offset': offset,
+      'length': length,
+      'targets': [target]
+    });
+  }
+
+  void _addRegion_nodeStart_nodeEnd(AstNode a, AstNode b, Element element) {
+    int offset = a.offset;
+    int length = b.end - offset;
+    _addRegion(offset, length, element);
+  }
+
+  void _addRegion_nodeStart_nodeStart(AstNode a, AstNode b, Element element) {
+    int offset = a.offset;
+    int length = b.offset - offset;
+    _addRegion(offset, length, element);
+  }
+
+  void _addRegion_tokenStart_nodeEnd(Token a, AstNode b, Element element) {
+    int offset = a.offset;
+    int length = b.end - offset;
+    _addRegion(offset, length, element);
+  }
+
+  void _addRegionForNode(AstNode node, Element element) {
+    int offset = node.offset;
+    int length = node.length;
+    _addRegion(offset, length, element);
+  }
+
+  void _addRegionForToken(Token token, Element element) {
+    int offset = token.offset;
+    int length = token.length;
+    _addRegion(offset, length, element);
+  }
+
+  /**
+   * Returns the JSON for the given [Element], maybe `null` if `null` was given.
+   */
+  Map<String, Object> _createTarget(Element element) {
+    if (element == null) {
+      return null;
+    }
+    if (element is FieldFormalParameterElement) {
+      element = (element as FieldFormalParameterElement).field;
+    }
+    // prepare Source
+    Source source = element.source;
+    if (source == null) {
+      return null;
+    }
+    // prepare location
+    int offset = element.nameOffset;
+    int length = element.displayName.length;
+    if (element is CompilationUnitElement) {
+      offset = 0;
+      length = 0;
+    }
+    // return as JSON
+    return {
+      'file': source.fullName,
+      'offset': offset,
+      'length': length,
+      'elementId': element.location.encoding
+    };
+  }
+}
+
+
+
+class _DartUnitNavigationComputerVisitor extends RecursiveAstVisitor {
+  final DartUnitNavigationComputer computer;
+
+  _DartUnitNavigationComputerVisitor(this.computer);
+
+  @override
+  visitAssignmentExpression(AssignmentExpression node) {
+    computer._addRegionForToken(node.operator, node.bestElement);
+    return super.visitAssignmentExpression(node);
+  }
+
+  @override
+  visitBinaryExpression(BinaryExpression node) {
+    computer._addRegionForToken(node.operator, node.bestElement);
+    return super.visitBinaryExpression(node);
+  }
+
+  @override
+  visitConstructorDeclaration(ConstructorDeclaration node) {
+    // associate constructor with "T" or "T.name"
+    {
+      AstNode firstNode = node.returnType;
+      AstNode lastNode = node.name;
+      if (lastNode == null) {
+        lastNode = firstNode;
+      }
+      if (firstNode != null && lastNode != null) {
+        computer._addRegion_nodeStart_nodeEnd(firstNode, lastNode, node.element);
+      }
+    }
+    return super.visitConstructorDeclaration(node);
+  }
+
+  @override
+  visitExportDirective(ExportDirective node) {
+    ExportElement exportElement = node.element;
+    if (exportElement != null) {
+      Element element = exportElement.exportedLibrary;
+      computer._addRegion_tokenStart_nodeEnd(node.keyword, node.uri, element);
+    }
+    return super.visitExportDirective(node);
+  }
+
+  @override
+  visitImportDirective(ImportDirective node) {
+    ImportElement importElement = node.element;
+    if (importElement != null) {
+      Element element = importElement.importedLibrary;
+      computer._addRegion_tokenStart_nodeEnd(node.keyword, node.uri, element);
+    }
+    return super.visitImportDirective(node);
+  }
+
+  @override
+  visitIndexExpression(IndexExpression node) {
+    computer._addRegionForToken(node.rightBracket, node.bestElement);
+    return super.visitIndexExpression(node);
+  }
+
+  @override
+  visitInstanceCreationExpression(InstanceCreationExpression node) {
+    Element element = node.staticElement;
+    if (element != null && element.isSynthetic) {
+      element = element.enclosingElement;
+    }
+    computer._addRegion_nodeStart_nodeStart(node, node.argumentList, element);
+    return super.visitInstanceCreationExpression(node);
+  }
+
+  @override
+  visitPartDirective(PartDirective node) {
+    computer._addRegion_tokenStart_nodeEnd(node.keyword, node.uri, node.element);
+    return super.visitPartDirective(node);
+  }
+
+  @override
+  visitPartOfDirective(PartOfDirective node) {
+    computer._addRegion_tokenStart_nodeEnd(node.keyword, node.libraryName, node.element);
+    return super.visitPartOfDirective(node);
+  }
+
+  @override
+  visitPostfixExpression(PostfixExpression node) {
+    computer._addRegionForToken(node.operator, node.bestElement);
+    return super.visitPostfixExpression(node);
+  }
+
+  @override
+  visitPrefixExpression(PrefixExpression node) {
+    computer._addRegionForToken(node.operator, node.bestElement);
+    return super.visitPrefixExpression(node);
+  }
+
+  @override
+  visitSimpleIdentifier(SimpleIdentifier node) {
+    if (node.parent is ConstructorDeclaration) {
+    } else {
+      computer._addRegionForNode(node, node.bestElement);
+    }
+    return super.visitSimpleIdentifier(node);
+  }
+}
diff --git a/pkg/analysis_server/lib/src/computer/computer_outline.dart b/pkg/analysis_server/lib/src/computer/computer_outline.dart
new file mode 100644
index 0000000..3609759
--- /dev/null
+++ b/pkg/analysis_server/lib/src/computer/computer_outline.dart
@@ -0,0 +1,373 @@
+// 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 computer.outline;
+
+import 'package:analysis_server/src/constants.dart';
+import 'package:analyzer/src/generated/ast.dart';
+
+
+/**
+ * A computer for [CompilationUnit] outline.
+ */
+class DartUnitOutlineComputer {
+  final CompilationUnit _unit;
+
+  DartUnitOutlineComputer(this._unit);
+
+  /**
+   * Returns the computed outline, not `null`.
+   */
+  Map<String, Object> compute() {
+    _Outline unitOutline = _newUnitOutline();
+    for (CompilationUnitMember unitMember in _unit.declarations) {
+      if (unitMember is ClassDeclaration) {
+        ClassDeclaration classDeclaration = unitMember;
+        _Outline classOutline = _newClassOutline(unitOutline, classDeclaration);
+        for (ClassMember classMember in classDeclaration.members) {
+          if (classMember is ConstructorDeclaration) {
+            ConstructorDeclaration constructorDeclaration = classMember;
+            _newConstructorOutline(classOutline, constructorDeclaration);
+          }
+          if (classMember is FieldDeclaration) {
+            FieldDeclaration fieldDeclaration = classMember;
+            VariableDeclarationList fields = fieldDeclaration.fields;
+            if (fields != null) {
+              TypeName fieldType = fields.type;
+              String fieldTypeName = fieldType != null ? fieldType.toSource() : "";
+              for (VariableDeclaration field in fields.variables) {
+                _newVariableOutline(classOutline, fieldTypeName, _OutlineKind.FIELD, field, fieldDeclaration.isStatic);
+              }
+            }
+          }
+          if (classMember is MethodDeclaration) {
+            MethodDeclaration methodDeclaration = classMember;
+            _newMethodOutline(classOutline, methodDeclaration);
+          }
+        }
+      }
+      if (unitMember is TopLevelVariableDeclaration) {
+        TopLevelVariableDeclaration fieldDeclaration = unitMember;
+        VariableDeclarationList fields = fieldDeclaration.variables;
+        if (fields != null) {
+          TypeName fieldType = fields.type;
+          String fieldTypeName = fieldType != null ? fieldType.toSource() : "";
+          for (VariableDeclaration field in fields.variables) {
+            _newVariableOutline(unitOutline, fieldTypeName, _OutlineKind.TOP_LEVEL_VARIABLE, field, false);
+          }
+        }
+      }
+      if (unitMember is FunctionDeclaration) {
+        FunctionDeclaration functionDeclaration = unitMember;
+        _newFunctionOutline(unitOutline, functionDeclaration);
+      }
+      if (unitMember is ClassTypeAlias) {
+        ClassTypeAlias alias = unitMember;
+        _newClassTypeAlias(unitOutline, alias);
+      }
+      if (unitMember is FunctionTypeAlias) {
+        FunctionTypeAlias alias = unitMember;
+        _newFunctionTypeAliasOutline(unitOutline, alias);
+      }
+    }
+    return unitOutline.toJson();
+  }
+
+  void _addLocalFunctionOutlines(_Outline parent, FunctionBody body) {
+    body.accept(new _LocalFunctionOutlinesVisitor(this, parent));
+  }
+
+  /**
+   * Returns the [AstNode]'s source region.
+   */
+  _SourceRegion _getSourceRegion(AstNode node) {
+    int endOffset = node.end;
+    // prepare position of the node among its siblings
+    int firstOffset;
+    List<AstNode> siblings;
+    AstNode parent = node.parent;
+    // field
+    if (parent is VariableDeclarationList) {
+      VariableDeclarationList variableList = parent as VariableDeclarationList;
+      List<VariableDeclaration> variables = variableList.variables;
+      int variableIndex = variables.indexOf(node);
+      if (variableIndex == variables.length - 1) {
+        endOffset = variableList.parent.end;
+      }
+      if (variableIndex == 0) {
+        node = parent.parent;
+        parent = node.parent;
+      } else if (variableIndex >= 1) {
+        firstOffset = variables[variableIndex - 1].end;
+        return new _SourceRegion(firstOffset, endOffset - firstOffset);
+      }
+    }
+    // unit or class member
+    if (parent is CompilationUnit) {
+      firstOffset = 0;
+      siblings = (parent as CompilationUnit).declarations;
+    } else if (parent is ClassDeclaration) {
+      ClassDeclaration classDeclaration = parent as ClassDeclaration;
+      firstOffset = classDeclaration.leftBracket.end;
+      siblings = classDeclaration.members;
+    } else {
+      int offset = node.offset;
+      return new _SourceRegion(offset, endOffset - offset);
+    }
+    // first child: [endOfParent, endOfNode]
+    int index = siblings.indexOf(node);
+    if (index == 0) {
+      return new _SourceRegion(firstOffset, endOffset - firstOffset);
+    }
+    // not first child: [endOfPreviousSibling, endOfNode]
+    int prevSiblingEnd = siblings[index - 1].end;
+    return new _SourceRegion(prevSiblingEnd, endOffset - prevSiblingEnd);
+  }
+
+  _Outline _newClassOutline(_Outline parent, ClassDeclaration classDeclaration) {
+    SimpleIdentifier nameNode = classDeclaration.name;
+    String name = nameNode.name;
+    _SourceRegion sourceRegion = _getSourceRegion(classDeclaration);
+    _Outline outline = new _Outline(
+        _OutlineKind.CLASS, name,
+        nameNode.offset, nameNode.length,
+        sourceRegion.offset, sourceRegion.length,
+        classDeclaration.isAbstract, false,
+        null, null);
+    parent.children.add(outline);
+    return outline;
+  }
+
+  void _newClassTypeAlias(_Outline parent, ClassTypeAlias alias) {
+    SimpleIdentifier nameNode = alias.name;
+    String name = nameNode.name;
+    _SourceRegion sourceRegion = _getSourceRegion(alias);
+    _Outline outline = new _Outline(
+        _OutlineKind.CLASS_TYPE_ALIAS, name,
+        nameNode.offset, nameNode.length,
+        sourceRegion.offset, sourceRegion.length,
+        alias.isAbstract, false,
+        null, null);
+    parent.children.add(outline);
+  }
+
+  void _newConstructorOutline(_Outline parent, ConstructorDeclaration constructor) {
+    Identifier returnType = constructor.returnType;
+    String name = returnType.name;
+    int offset = returnType.offset;
+    int length = returnType.length;
+    SimpleIdentifier constructorNameNode = constructor.name;
+    if (constructorNameNode != null) {
+      String constructorName = constructorNameNode.name;
+      name += ".${constructorName}";
+      offset = constructorNameNode.offset;
+      length = constructorNameNode.length;
+    }
+    _SourceRegion sourceRegion = _getSourceRegion(constructor);
+    FormalParameterList parameters = constructor.parameters;
+    String parametersStr = parameters != null ? parameters.toSource() : "";
+    _Outline outline = new _Outline(
+        _OutlineKind.CONSTRUCTOR, name,
+        offset, length,
+        sourceRegion.offset, sourceRegion.length,
+        false, false,
+        parametersStr, null);
+    parent.children.add(outline);
+    _addLocalFunctionOutlines(outline, constructor.body);
+  }
+
+  void _newFunctionOutline(_Outline parent, FunctionDeclaration function) {
+    TypeName returnType = function.returnType;
+    SimpleIdentifier nameNode = function.name;
+    String name = nameNode.name;
+    FunctionExpression functionExpression = function.functionExpression;
+    FormalParameterList parameters = functionExpression.parameters;
+    _OutlineKind kind;
+    if (function.isGetter) {
+      kind = _OutlineKind.GETTER;
+    } else if (function.isSetter) {
+      kind = _OutlineKind.SETTER;
+    } else {
+      kind = _OutlineKind.FUNCTION;
+    }
+    _SourceRegion sourceRegion = _getSourceRegion(function);
+    String parametersStr = parameters != null ? parameters.toSource() : "";
+    String returnTypeStr = returnType != null ? returnType.toSource() : "";
+    _Outline outline = new _Outline(
+        kind, name,
+        nameNode.offset, nameNode.length,
+        sourceRegion.offset, sourceRegion.length,
+        false, false,
+        parametersStr, returnTypeStr);
+    parent.children.add(outline);
+    _addLocalFunctionOutlines(outline, functionExpression.body);
+  }
+
+  void _newFunctionTypeAliasOutline(_Outline parent, FunctionTypeAlias alias) {
+    TypeName returnType = alias.returnType;
+    SimpleIdentifier nameNode = alias.name;
+    String name = nameNode.name;
+    _SourceRegion sourceRegion = _getSourceRegion(alias);
+    FormalParameterList parameters = alias.parameters;
+    String parametersStr = parameters != null ? parameters.toSource() : "";
+    String returnTypeStr = returnType != null ? returnType.toSource() : "";
+    _Outline outline = new _Outline(
+        _OutlineKind.FUNCTION_TYPE_ALIAS, name,
+        nameNode.offset, nameNode.length,
+        sourceRegion.offset, sourceRegion.length,
+        false, false,
+        parametersStr, returnTypeStr);
+    parent.children.add(outline);
+  }
+
+  void _newMethodOutline(_Outline parent, MethodDeclaration method) {
+    TypeName returnType = method.returnType;
+    SimpleIdentifier nameNode = method.name;
+    String name = nameNode.name;
+    FormalParameterList parameters = method.parameters;
+    _OutlineKind kind;
+    if (method.isGetter) {
+      kind = _OutlineKind.GETTER;
+    } else if (method.isSetter) {
+      kind = _OutlineKind.SETTER;
+    } else {
+      kind = _OutlineKind.METHOD;
+    }
+    _SourceRegion sourceRegion = _getSourceRegion(method);
+    String parametersStr = parameters != null ? parameters.toSource() : "";
+    String returnTypeStr = returnType != null ? returnType.toSource() : "";
+    _Outline outline = new _Outline(
+        kind, name,
+        nameNode.offset, nameNode.length,
+        sourceRegion.offset, sourceRegion.length,
+        method.isAbstract, method.isStatic,
+        parametersStr, returnTypeStr);
+    parent.children.add(outline);
+    _addLocalFunctionOutlines(outline, method.body);
+  }
+
+  _Outline _newUnitOutline() {
+    return new _Outline(
+        _OutlineKind.COMPILATION_UNIT, "<unit>",
+        _unit.offset, _unit.length,
+        _unit.offset, _unit.length,
+        false, false,
+        null, null);
+  }
+
+  void _newVariableOutline(_Outline parent, String typeName, _OutlineKind kind, VariableDeclaration variable, bool isStatic) {
+    SimpleIdentifier nameNode = variable.name;
+    String name = nameNode.name;
+    _SourceRegion sourceRegion = _getSourceRegion(variable);
+    _Outline outline = new _Outline(
+        kind, name,
+        nameNode.offset, nameNode.length,
+        sourceRegion.offset, sourceRegion.length,
+        false, isStatic,
+        null, typeName);
+    parent.children.add(outline);
+  }
+}
+
+
+/**
+ * A visitor for building local function outlines.
+ */
+class _LocalFunctionOutlinesVisitor extends RecursiveAstVisitor {
+  final DartUnitOutlineComputer outlineComputer;
+  final _Outline parent;
+
+  _LocalFunctionOutlinesVisitor(this.outlineComputer, this.parent);
+
+  @override
+  visitFunctionDeclaration(FunctionDeclaration node) {
+    outlineComputer._newFunctionOutline(parent, node);
+  }
+}
+
+
+
+/**
+ * A range of characters.
+ */
+class _SourceRegion {
+  final int offset;
+  final int length;
+  _SourceRegion(this.offset, this.length);
+}
+
+
+/**
+ * Element outline kinds.
+ */
+class _OutlineKind {
+  static const _OutlineKind CLASS = const _OutlineKind('CLASS');
+  static const _OutlineKind CLASS_TYPE_ALIAS = const _OutlineKind('CLASS_TYPE_ALIAS');
+  static const _OutlineKind COMPILATION_UNIT = const _OutlineKind('COMPILATION_UNIT');
+  static const _OutlineKind CONSTRUCTOR = const _OutlineKind('CONSTRUCTOR');
+  static const _OutlineKind GETTER = const _OutlineKind('GETTER');
+  static const _OutlineKind FIELD = const _OutlineKind('FIELD');
+  static const _OutlineKind FUNCTION = const _OutlineKind('FUNCTION');
+  static const _OutlineKind FUNCTION_TYPE_ALIAS = const _OutlineKind('FUNCTION_TYPE_ALIAS');
+  static const _OutlineKind LIBRARY = const _OutlineKind('LIBRARY');
+  static const _OutlineKind METHOD = const _OutlineKind('METHOD');
+  static const _OutlineKind SETTER = const _OutlineKind('SETTER');
+  static const _OutlineKind TOP_LEVEL_VARIABLE = const _OutlineKind('TOP_LEVEL_VARIABLE');
+  static const _OutlineKind UNKNOWN = const _OutlineKind('UNKNOWN');
+  static const _OutlineKind UNIT_TEST_CASE = const _OutlineKind('UNIT_TEST_CASE');
+  static const _OutlineKind UNIT_TEST_GROUP = const _OutlineKind('UNIT_TEST_GROUP');
+
+  final String name;
+
+  const _OutlineKind(this.name);
+}
+
+
+/**
+ * An element outline.
+ */
+class _Outline {
+  static const List<_Outline> EMPTY_ARRAY = const <_Outline>[];
+
+  final _OutlineKind kind;
+  final String name;
+  final int nameOffset;
+  final int nameLength;
+  final int elementOffset;
+  final int elementLength;
+  final bool isAbstract;
+  final bool isStatic;
+  final String parameters;
+  final String returnType;
+  final List<_Outline> children = <_Outline>[];
+
+  _Outline(this.kind, this.name,
+           this.nameOffset, this.nameLength,
+           this.elementOffset, this.elementLength,
+           this.isAbstract, this.isStatic,
+           this.parameters, this.returnType);
+
+  Map<String, Object> toJson() {
+    Map<String, Object> json = {
+      KIND: kind.name,
+      NAME: name,
+      NAME_OFFSET: nameOffset,
+      NAME_LENGTH: nameLength,
+      ELEMENT_OFFSET: elementOffset,
+      ELEMENT_LENGTH: elementLength,
+      IS_ABSTRACT: isAbstract,
+      IS_STATIC: isStatic
+    };
+    if (parameters != null) {
+      json[PARAMETERS] = parameters;
+    }
+    if (returnType != null) {
+      json[RETURN_TYPE] = returnType;
+    }
+    if (children.isNotEmpty) {
+      json[CHILDREN] = children.map((child) => child.toJson()).toList();
+    }
+    return json;
+  }
+}
diff --git a/pkg/analysis_server/test/analysis_abstract.dart b/pkg/analysis_server/test/analysis_abstract.dart
new file mode 100644
index 0000000..2ea2e1d
--- /dev/null
+++ b/pkg/analysis_server/test/analysis_abstract.dart
@@ -0,0 +1,280 @@
+// 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 test.domain.analysis.abstract;
+
+import 'dart:async';
+
+import 'package:analysis_server/src/analysis_server.dart';
+import 'package:analysis_server/src/domain_analysis.dart';
+import 'package:analysis_server/src/constants.dart';
+import 'package:analysis_server/src/protocol.dart';
+import 'package:analysis_server/src/resource.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:unittest/unittest.dart';
+
+import 'mocks.dart';
+
+
+/**
+ * An abstract base for all 'analysis' domain tests.
+ */
+class AbstractAnalysisTest {
+  MockServerChannel serverChannel;
+  MemoryResourceProvider resourceProvider;
+  AnalysisServer server;
+  AnalysisDomainHandler handler;
+
+  Map<String, List<String>> analysisSubscriptions = {};
+
+  String projectPath = '/project';
+  String testFile = '/project/bin/test.dart';
+  String testCode;
+
+//  Map<String, List<AnalysisError>> filesErrors = {};
+//  Map<String, List<Map<String, Object>>> filesHighlights = {};
+//  Map<String, List<Map<String, Object>>> filesNavigation = {};
+
+
+  AbstractAnalysisTest() {
+  }
+
+  void setUp() {
+    serverChannel = new MockServerChannel();
+    resourceProvider = new MemoryResourceProvider();
+    server = new AnalysisServer(serverChannel, resourceProvider);
+    handler = new AnalysisDomainHandler(server);
+    // listen for notifications
+    Stream<Notification> notificationStream = serverChannel.notificationController.stream;
+    notificationStream.listen((Notification notification) {
+      processNotification(notification);
+    });
+    // create an empty project
+    _createEmptyProject();
+  }
+
+  void addAnalysisSubscription(AnalysisService service, String file) {
+    // add file to subscription
+    var files = analysisSubscriptions[service.name];
+    if (files == null) {
+      files = <String>[];
+      analysisSubscriptions[service.name] = files;
+    }
+    files.add(file);
+    // set subscriptions
+    Request request = new Request('0', METHOD_SET_ANALYSIS_SUBSCRIPTIONS);
+    request.setParameter(SUBSCRIPTIONS, analysisSubscriptions);
+    handleSuccessfulRequest(request);
+  }
+
+  void tearDown() {
+    server.done();
+    handler = null;
+    server = null;
+    resourceProvider = null;
+    serverChannel = null;
+  }
+
+  void processNotification(Notification notification) {
+//    if (notification.event == NOTIFICATION_ERRORS) {
+//      String file = notification.getParameter(FILE);
+//      List<Map<String, Object>> errorMaps = notification.getParameter(ERRORS);
+//      filesErrors[file] = errorMaps.map(jsonToAnalysisError).toList();
+//    }
+//    if (notification.event == NOTIFICATION_HIGHLIGHTS) {
+//      String file = notification.getParameter(FILE);
+//      filesHighlights[file] = notification.getParameter(REGIONS);
+//    }
+//    if (notification.event == NOTIFICATION_NAVIGATION) {
+//      String file = notification.getParameter(FILE);
+//      filesNavigation[file] = notification.getParameter(REGIONS);
+//    }
+  }
+
+  /**
+   * Returns a [Future] that completes when the [AnalysisServer] finishes
+   * all its scheduled tasks.
+   */
+  Future waitForTasksFinished() {
+    return waitForServerOperationsPerformed(server);
+  }
+
+  /**
+   * Returns the offset of [search] in [testCode].
+   * Fails if not found.
+   */
+  int findFileOffset(String path, String search) {
+    File file = resourceProvider.getResource(path) as File;
+    String code = file.createSource(UriKind.FILE_URI).contents.data;
+    int offset = code.indexOf(search);
+    expect(offset, isNot(-1), reason: '"$search" in\n$code');
+    return offset;
+  }
+
+  /**
+   * Returns the offset of [search] in [testCode].
+   * Fails if not found.
+   */
+  int findOffset(String search) {
+    int offset = testCode.indexOf(search);
+    expect(offset, isNot(-1));
+    return offset;
+  }
+
+//  /**
+//   * Returns [AnalysisError]s recorded for the given [file].
+//   * May be empty, but not `null`.
+//   */
+//  List<AnalysisError> getErrors(String file) {
+//    List<AnalysisError> errors = filesErrors[file];
+//    if (errors != null) {
+//      return errors;
+//    }
+//    return <AnalysisError>[];
+//  }
+//
+//  /**
+//   * Returns highlights recorded for the given [file].
+//   * May be empty, but not `null`.
+//   */
+//  List<Map<String, Object>> getHighlights(String file) {
+//    List<Map<String, Object>> highlights = filesHighlights[file];
+//    if (highlights != null) {
+//      return highlights;
+//    }
+//    return [];
+//  }
+//
+//  /**
+//   * Returns navigation regions recorded for the given [file].
+//   * May be empty, but not `null`.
+//   */
+//  List<Map<String, Object>> getNavigation(String file) {
+//    List<Map<String, Object>> navigation = filesNavigation[file];
+//    if (navigation != null) {
+//      return navigation;
+//    }
+//    return [];
+//  }
+//
+//  /**
+//   * Returns [AnalysisError]s recorded for the [testFile].
+//   * May be empty, but not `null`.
+//   */
+//  List<AnalysisError> getTestErrors() {
+//    return getErrors(testFile);
+//  }
+//
+//  /**
+//   * Returns highlights recorded for the given [testFile].
+//   * May be empty, but not `null`.
+//   */
+//  List<Map<String, Object>> getTestHighlights() {
+//    return getHighlights(testFile);
+//  }
+//
+//  /**
+//   * Returns navigation information recorded for the given [testFile].
+//   * May be empty, but not `null`.
+//   */
+//  List<Map<String, Object>> getTestNavigation() {
+//    return getNavigation(testFile);
+//  }
+
+  /**
+   * Creates an empty project `/project/`.
+   */
+  void _createEmptyProject() {
+    resourceProvider.newFolder(projectPath);
+    Request request = new Request('0', METHOD_SET_ANALYSIS_ROOTS);
+    request.setParameter(INCLUDED, [projectPath]);
+    request.setParameter(EXCLUDED, []);
+    handleSuccessfulRequest(request);
+  }
+
+//  /**
+//   * Creates a project with a single Dart file `/project/bin/test.dart` with
+//   * the given [code].
+//   */
+//  void createSingleFileProject(code) {
+//    this.testCode = _getCodeString(code);
+//    resourceProvider.newFolder('/project');
+//    resourceProvider.newFile(testFile, testCode);
+//    Request request = new Request('0', METHOD_SET_ANALYSIS_ROOTS);
+//    request.setParameter(INCLUDED, ['/project']);
+//    request.setParameter(EXCLUDED, []);
+//    handleSuccessfulRequest(request);
+//  }
+
+  String addFile(String path, String content) {
+    resourceProvider.newFile(path, content);
+    return path;
+  }
+
+  String addTestFile(String content) {
+    addFile(testFile, content);
+    this.testCode = content;
+    return testFile;
+  }
+
+  /**
+   * Validates that the given [request] is handled successfully.
+   */
+  void handleSuccessfulRequest(Request request) {
+    Response response = handler.handleRequest(request);
+    expect(response, isResponseSuccess('0'));
+  }
+
+  static String _getCodeString(code) {
+    if (code is List<String>) {
+      code = code.join('\n');
+    }
+    return code as String;
+  }
+}
+
+
+
+class AnalysisError {
+  final String file;
+  final String errorCode;
+  final int offset;
+  final int length;
+  final String message;
+  final String correction;
+  AnalysisError(this.file, this.errorCode, this.offset, this.length,
+      this.message, this.correction);
+
+  @override
+  String toString() {
+    return 'NotificationError(file=$file; errorCode=$errorCode; '
+        'offset=$offset; length=$length; message=$message)';
+  }
+}
+
+
+AnalysisError _jsonToAnalysisError(Map<String, Object> json) {
+  return new AnalysisError(
+      json['file'],
+      json['errorCode'],
+      json['offset'],
+      json['length'],
+      json['message'],
+      json['correction']);
+}
+
+
+int findIdentifierLength(String search) {
+  int length = 0;
+  while (length < search.length) {
+    int c = search.codeUnitAt(length);
+    if (!(c >= 'a'.codeUnitAt(0) && c <= 'z'.codeUnitAt(0) ||
+          c >= 'A'.codeUnitAt(0) && c <= 'Z'.codeUnitAt(0) ||
+          c >= '0'.codeUnitAt(0) && c <= '9'.codeUnitAt(0))) {
+      break;
+    }
+    length++;
+  }
+  return length;
+}
diff --git a/pkg/analysis_server/test/analysis_notification_outline_test.dart b/pkg/analysis_server/test/analysis_notification_outline_test.dart
new file mode 100644
index 0000000..49011ef
--- /dev/null
+++ b/pkg/analysis_server/test/analysis_notification_outline_test.dart
@@ -0,0 +1,681 @@
+// 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 test.domain.analysis.notification.outline;
+
+import 'dart:async';
+import 'dart:mirrors';
+
+import 'package:analysis_server/src/analysis_server.dart';
+import 'package:analysis_server/src/constants.dart';
+import 'package:analysis_server/src/protocol.dart';
+import 'package:unittest/unittest.dart';
+
+import 'analysis_abstract.dart';
+import 'reflective_tests.dart';
+
+
+main() {
+  group('notification.outline', () {
+    runReflectiveTests(AnalysisNotificationOutlineTest);
+  });
+}
+
+
+@ReflectiveTestCase()
+class AnalysisNotificationOutlineTest extends AbstractAnalysisTest {
+  _Outline outline;
+
+  void processNotification(Notification notification) {
+    if (notification.event == NOTIFICATION_OUTLINE) {
+      String file = notification.getParameter(FILE);
+      if (file == testFile) {
+        Map<String, Object> json = notification.getParameter(OUTLINE);
+        outline = new _Outline.fromJson(json);
+      }
+    }
+  }
+
+  Future prepareOutline(then()) {
+    addAnalysisSubscription(AnalysisService.OUTLINE, testFile);
+    return waitForTasksFinished().then((_) {
+      then();
+    });
+  }
+
+  test_class() {
+    addTestFile('''
+class A {
+  int fa, fb;
+  String fc;
+  A(int i, String s);
+  A.name(num p);
+  A._privateName(num p);
+  static String ma(int pa) => null;
+  _mb(int pb);
+  String get propA => null;
+  set propB(int v) {}
+}
+class B {
+  B(int p);
+}");
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> topOutlines = unitOutline.children;
+      expect(topOutlines, hasLength(2));
+      // A
+      {
+        _Outline outline_A = topOutlines[0];
+        expect(outline_A.kind, _OutlineKind.CLASS);
+        expect(outline_A.name, "A");
+        expect(outline_A.nameOffset, testCode.indexOf("A {"));
+        expect(outline_A.nameLength, 1);
+        expect(outline_A.parameters, null);
+        expect(outline_A.returnType, null);
+        // A children
+        List<_Outline> outlines_A = outline_A.children;
+        expect(outlines_A, hasLength(10));
+        {
+          _Outline outline = outlines_A[0];
+          expect(outline.kind, _OutlineKind.FIELD);
+          expect(outline.name, "fa");
+          expect(outline.parameters, isNull);
+          expect(outline.returnType, "int");
+        }
+        {
+          _Outline outline = outlines_A[1];
+          expect(outline.kind, _OutlineKind.FIELD);
+          expect(outline.name, "fb");
+          expect(outline.parameters, isNull);
+          expect(outline.returnType, "int");
+        }
+        {
+          _Outline outline = outlines_A[2];
+          expect(outline.kind, _OutlineKind.FIELD);
+          expect(outline.name, "fc");
+          expect(outline.parameters, isNull);
+          expect(outline.returnType, "String");
+        }
+        {
+          _Outline outline = outlines_A[3];
+          expect(outline.kind, _OutlineKind.CONSTRUCTOR);
+          expect(outline.name, "A");
+          expect(outline.nameOffset, testCode.indexOf("A(int i, String s);"));
+          expect(outline.nameLength, "A".length);
+          expect(outline.parameters, "(int i, String s)");
+          expect(outline.returnType, isNull);
+          expect(outline.isAbstract, isFalse);
+          expect(outline.isStatic, isFalse);
+        }
+        {
+          _Outline outline = outlines_A[4];
+          expect(outline.kind, _OutlineKind.CONSTRUCTOR);
+          expect(outline.name, "A.name");
+          expect(outline.nameOffset, testCode.indexOf("name(num p);"));
+          expect(outline.nameLength, "name".length);
+          expect(outline.parameters, "(num p)");
+          expect(outline.returnType, isNull);
+          expect(outline.isAbstract, isFalse);
+          expect(outline.isStatic, isFalse);
+        }
+        {
+          _Outline outline = outlines_A[5];
+          expect(outline.kind, _OutlineKind.CONSTRUCTOR);
+          expect(outline.name, "A._privateName");
+          expect(outline.nameOffset, testCode.indexOf("_privateName(num p);"));
+          expect(outline.nameLength, "_privateName".length);
+          expect(outline.parameters, "(num p)");
+          expect(outline.returnType, isNull);
+          expect(outline.isAbstract, isFalse);
+          expect(outline.isStatic, isFalse);
+        }
+        {
+          _Outline outline = outlines_A[6];
+          expect(outline.kind, _OutlineKind.METHOD);
+          expect(outline.name, "ma");
+          expect(outline.nameOffset, testCode.indexOf("ma(int pa) => null;"));
+          expect(outline.nameLength, "ma".length);
+          expect(outline.parameters, "(int pa)");
+          expect(outline.returnType, "String");
+          expect(outline.isAbstract, isFalse);
+          expect(outline.isStatic, isTrue);
+        }
+        {
+          _Outline outline = outlines_A[7];
+          expect(outline.kind, _OutlineKind.METHOD);
+          expect(outline.name, "_mb");
+          expect(outline.nameOffset, testCode.indexOf("_mb(int pb);"));
+          expect(outline.nameLength, "_mb".length);
+          expect(outline.parameters, "(int pb)");
+          expect(outline.returnType, "");
+          expect(outline.isAbstract, isTrue);
+          expect(outline.isStatic, isFalse);
+        }
+        {
+          _Outline outline = outlines_A[8];
+          expect(outline.kind, _OutlineKind.GETTER);
+          expect(outline.name, "propA");
+          expect(outline.nameOffset, testCode.indexOf("propA => null;"));
+          expect(outline.nameLength, "propA".length);
+          expect(outline.parameters, "");
+          expect(outline.returnType, "String");
+        }
+        {
+          _Outline outline = outlines_A[9];
+          expect(outline.kind, _OutlineKind.SETTER);
+          expect(outline.name, "propB");
+          expect(outline.nameOffset, testCode.indexOf("propB(int v) {}"));
+          expect(outline.nameLength, "propB".length);
+          expect(outline.parameters, "(int v)");
+          expect(outline.returnType, "");
+        }
+      }
+      // B
+      {
+        _Outline outline_B = topOutlines[1];
+        expect(outline_B.kind, _OutlineKind.CLASS);
+        expect(outline_B.name, "B");
+        expect(outline_B.nameOffset, testCode.indexOf("B {"));
+        expect(outline_B.nameLength, 1);
+        expect(outline_B.parameters, null);
+        expect(outline_B.returnType, null);
+        // B children
+        List<_Outline> outlines_B = outline_B.children;
+        expect(outlines_B, hasLength(1));
+        {
+          _Outline outline = outlines_B[0];
+          expect(outline.kind, _OutlineKind.CONSTRUCTOR);
+          expect(outline.name, "B");
+          expect(outline.nameOffset, testCode.indexOf("B(int p);"));
+          expect(outline.nameLength, "B".length);
+          expect(outline.parameters, "(int p)");
+          expect(outline.returnType, isNull);
+        }
+      }
+    });
+  }
+
+  test_sourceRange_inClass() {
+    addTestFile('''
+class A { // leftA
+  int methodA() {} // endA
+  int methodB() {} // endB
+}
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> outlines = unitOutline.children[0].children;
+      expect(outlines, hasLength(2));
+      // methodA
+      {
+        _Outline outline = outlines[0];
+        expect(outline.kind, _OutlineKind.METHOD);
+        expect(outline.name, "methodA");
+        {
+          int offset = testCode.indexOf(" // leftA");
+          int end = testCode.indexOf(" // endA");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // methodB
+      {
+        _Outline outline = outlines[1];
+        expect(outline.kind, _OutlineKind.METHOD);
+        expect(outline.name, "methodB");
+        {
+          int offset = testCode.indexOf(" // endA");
+          int end = testCode.indexOf(" // endB");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+    });
+  }
+
+  test_sourceRange_inClass_inVariableList() {
+    addTestFile('''
+class A { // leftA
+  int fieldA, fieldB, fieldC; // marker
+  int fieldD; // marker2
+}
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> outlines = unitOutline.children[0].children;
+      expect(outlines, hasLength(4));
+      // fieldA
+      {
+        _Outline outline = outlines[0];
+        expect(outline.kind, _OutlineKind.FIELD);
+        expect(outline.name, "fieldA");
+        {
+          int offset = testCode.indexOf(" // leftA");
+          int end = testCode.indexOf(", fieldB");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // fieldB
+      {
+        _Outline outline = outlines[1];
+        expect(outline.kind, _OutlineKind.FIELD);
+        expect(outline.name, "fieldB");
+        {
+          int offset = testCode.indexOf(", fieldB");
+          int end = testCode.indexOf(", fieldC");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // fieldC
+      {
+        _Outline outline = outlines[2];
+        expect(outline.kind, _OutlineKind.FIELD);
+        expect(outline.name, "fieldC");
+        {
+          int offset = testCode.indexOf(", fieldC");
+          int end = testCode.indexOf(" // marker");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // fieldD
+      {
+        _Outline outline = outlines[3];
+        expect(outline.kind, _OutlineKind.FIELD);
+        expect(outline.name, "fieldD");
+        {
+          int offset = testCode.indexOf(" // marker");
+          int end = testCode.indexOf(" // marker2");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+    });
+  }
+
+  test_sourceRange_inUnit() {
+    addTestFile('''
+class A {
+} // endA
+class B {
+} // endB
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> topOutlines = unitOutline.children;
+      expect(topOutlines, hasLength(2));
+      // A
+      {
+        _Outline outline = topOutlines[0];
+        expect(outline.kind, _OutlineKind.CLASS);
+        expect(outline.name, "A");
+        {
+          int offset = 0;
+          int end = testCode.indexOf(" // endA");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // B
+      {
+        _Outline outline = topOutlines[1];
+        expect(outline.kind, _OutlineKind.CLASS);
+        expect(outline.name, "B");
+        {
+          int offset = testCode.indexOf(" // endA");
+          int end = testCode.indexOf(" // endB");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+    });
+  }
+
+  test_sourceRange_inUnit_inVariableList() {
+    addTestFile('''
+int fieldA, fieldB, fieldC; // marker
+int fieldD; // marker2
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> outlines = unitOutline.children;
+      expect(outlines, hasLength(4));
+      // fieldA
+      {
+        _Outline outline = outlines[0];
+        expect(outline.kind, _OutlineKind.TOP_LEVEL_VARIABLE);
+        expect(outline.name, "fieldA");
+        {
+          int offset = 0;
+          int end = testCode.indexOf(", fieldB");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // fieldB
+      {
+        _Outline outline = outlines[1];
+        expect(outline.kind, _OutlineKind.TOP_LEVEL_VARIABLE);
+        expect(outline.name, "fieldB");
+        {
+          int offset = testCode.indexOf(", fieldB");
+          int end = testCode.indexOf(", fieldC");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // fieldC
+      {
+        _Outline outline = outlines[2];
+        expect(outline.kind, _OutlineKind.TOP_LEVEL_VARIABLE);
+        expect(outline.name, "fieldC");
+        {
+          int offset = testCode.indexOf(", fieldC");
+          int end = testCode.indexOf(" // marker");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+      // fieldD
+      {
+        _Outline outline = outlines[3];
+        expect(outline.kind, _OutlineKind.TOP_LEVEL_VARIABLE);
+        expect(outline.name, "fieldD");
+        {
+          int offset = testCode.indexOf(" // marker");
+          int end = testCode.indexOf(" // marker2");
+          expect(outline.elementOffset, offset);
+          expect(outline.elementLength, end - offset);
+        }
+      }
+    });
+  }
+
+  test_localFunctions() {
+    addTestFile('''
+class A {
+  A() {
+    int local_A() {}
+  }
+  m() {
+    local_m() {}
+  }
+}
+f() {
+  local_f1(int i) {}
+  local_f2(String s) {
+    local_f21(int p) {}
+  }
+}
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> topOutlines = unitOutline.children;
+      expect(topOutlines, hasLength(2));
+      // A
+      {
+        _Outline outline_A = topOutlines[0];
+        expect(outline_A.kind, _OutlineKind.CLASS);
+        expect(outline_A.name, "A");
+        expect(outline_A.nameOffset, testCode.indexOf("A {"));
+        expect(outline_A.nameLength, "A".length);
+        expect(outline_A.parameters, null);
+        expect(outline_A.returnType, null);
+        // A children
+        List<_Outline> outlines_A = outline_A.children;
+        expect(outlines_A, hasLength(2));
+        {
+          _Outline constructorOutline = outlines_A[0];
+          expect(constructorOutline.kind, _OutlineKind.CONSTRUCTOR);
+          expect(constructorOutline.name, "A");
+          expect(constructorOutline.nameOffset, testCode.indexOf("A() {"));
+          expect(constructorOutline.nameLength, "A".length);
+          expect(constructorOutline.parameters, "()");
+          expect(constructorOutline.returnType, isNull);
+          // local function
+          List<_Outline> outlines_constructor = constructorOutline.children;
+          expect(outlines_constructor, hasLength(1));
+          {
+            _Outline outline = outlines_constructor[0];
+            expect(outline.kind, _OutlineKind.FUNCTION);
+            expect(outline.name, "local_A");
+            expect(outline.nameOffset, testCode.indexOf("local_A() {}"));
+            expect(outline.nameLength, "local_A".length);
+            expect(outline.parameters, "()");
+            expect(outline.returnType, "int");
+          }
+        }
+        {
+          _Outline outline_m = outlines_A[1];
+          expect(outline_m.kind, _OutlineKind.METHOD);
+          expect(outline_m.name, "m");
+          expect(outline_m.nameOffset, testCode.indexOf("m() {"));
+          expect(outline_m.nameLength, "m".length);
+          expect(outline_m.parameters, "()");
+          expect(outline_m.returnType, "");
+          // local function
+          List<_Outline> methodChildren = outline_m.children;
+          expect(methodChildren, hasLength(1));
+          {
+            _Outline outline = methodChildren[0];
+            expect(outline.kind, _OutlineKind.FUNCTION);
+            expect(outline.name, "local_m");
+            expect(outline.nameOffset, testCode.indexOf("local_m() {}"));
+            expect(outline.nameLength, "local_m".length);
+            expect(outline.parameters, "()");
+            expect(outline.returnType, "");
+          }
+        }
+      }
+      // f()
+      {
+        _Outline outline_f = topOutlines[1];
+        expect(outline_f.kind, _OutlineKind.FUNCTION);
+        expect(outline_f.name, "f");
+        expect(outline_f.nameOffset, testCode.indexOf("f() {"));
+        expect(outline_f.nameLength, "f".length);
+        expect(outline_f.parameters, "()");
+        expect(outline_f.returnType, "");
+        // f() children
+        List<_Outline> outlines_f = outline_f.children;
+        expect(outlines_f, hasLength(2));
+        {
+          _Outline outline_f1 = outlines_f[0];
+          expect(outline_f1.kind, _OutlineKind.FUNCTION);
+          expect(outline_f1.name, "local_f1");
+          expect(outline_f1.nameOffset, testCode.indexOf("local_f1(int i) {}"));
+          expect(outline_f1.nameLength, "local_f1".length);
+          expect(outline_f1.parameters, "(int i)");
+          expect(outline_f1.returnType, "");
+        }
+        {
+          _Outline outline_f2 = outlines_f[1];
+          expect(outline_f2.kind, _OutlineKind.FUNCTION);
+          expect(outline_f2.name, "local_f2");
+          expect(outline_f2.nameOffset, testCode.indexOf("local_f2(String s) {"));
+          expect(outline_f2.nameLength, "local_f2".length);
+          expect(outline_f2.parameters, "(String s)");
+          expect(outline_f2.returnType, "");
+          // local_f2() local function
+          List<_Outline> outlines_f2 = outline_f2.children;
+          expect(outlines_f2, hasLength(1));
+          {
+            _Outline outline_f21 = outlines_f2[0];
+            expect(outline_f21.kind, _OutlineKind.FUNCTION);
+            expect(outline_f21.name, "local_f21");
+            expect(outline_f21.nameOffset, testCode.indexOf("local_f21(int p) {"));
+            expect(outline_f21.nameLength, "local_f21".length);
+            expect(outline_f21.parameters, "(int p)");
+            expect(outline_f21.returnType, "");
+          }
+        }
+      }
+    });
+  }
+
+  test_topLevel() {
+    addTestFile('''
+typedef String FTA(int i, String s);
+typedef FTB(int p);
+class A {}
+class B {}
+class CTA = A with B;
+String fA(int i, String s) => null;
+fB(int p) => null;
+String get propA => null;
+set propB(int v) {}
+''');
+    return prepareOutline(() {
+      _Outline unitOutline = outline;
+      List<_Outline> topOutlines = unitOutline.children;
+      expect(topOutlines, hasLength(9));
+      // FTA
+      {
+        _Outline outline = topOutlines[0];
+        expect(outline.kind, _OutlineKind.FUNCTION_TYPE_ALIAS);
+        expect(outline.name, "FTA");
+        expect(outline.nameOffset, testCode.indexOf("FTA("));
+        expect(outline.nameLength, "FTA".length);
+        expect(outline.parameters, "(int i, String s)");
+        expect(outline.returnType, "String");
+      }
+      // FTB
+      {
+        _Outline outline = topOutlines[1];
+        expect(outline.kind, _OutlineKind.FUNCTION_TYPE_ALIAS);
+        expect(outline.name, "FTB");
+        expect(outline.nameOffset, testCode.indexOf("FTB("));
+        expect(outline.nameLength, "FTB".length);
+        expect(outline.parameters, "(int p)");
+        expect(outline.returnType, "");
+      }
+      // CTA
+      {
+        _Outline outline = topOutlines[4];
+        expect(outline.kind, _OutlineKind.CLASS_TYPE_ALIAS);
+        expect(outline.name, "CTA");
+        expect(outline.nameOffset, testCode.indexOf("CTA ="));
+        expect(outline.nameLength, "CTA".length);
+        expect(outline.parameters, isNull);
+        expect(outline.returnType, isNull);
+      }
+      // fA
+      {
+        _Outline outline = topOutlines[5];
+        expect(outline.kind, _OutlineKind.FUNCTION);
+        expect(outline.name, "fA");
+        expect(outline.nameOffset, testCode.indexOf("fA("));
+        expect(outline.nameLength, "fA".length);
+        expect(outline.parameters, "(int i, String s)");
+        expect(outline.returnType, "String");
+      }
+      // fB
+      {
+        _Outline outline = topOutlines[6];
+        expect(outline.kind, _OutlineKind.FUNCTION);
+        expect(outline.name, "fB");
+        expect(outline.nameOffset, testCode.indexOf("fB("));
+        expect(outline.nameLength, "fB".length);
+        expect(outline.parameters, "(int p)");
+        expect(outline.returnType, "");
+      }
+      // propA
+      {
+        _Outline outline = topOutlines[7];
+        expect(outline.kind, _OutlineKind.GETTER);
+        expect(outline.name, "propA");
+        expect(outline.nameOffset, testCode.indexOf("propA => null;"));
+        expect(outline.nameLength, "propA".length);
+        expect(outline.parameters, "");
+        expect(outline.returnType, "String");
+      }
+      // propB
+      {
+        _Outline outline = topOutlines[8];
+        expect(outline.kind, _OutlineKind.SETTER);
+        expect(outline.name, "propB");
+        expect(outline.nameOffset, testCode.indexOf("propB(int v) {}"));
+        expect(outline.nameLength, "propB".length);
+        expect(outline.parameters, "(int v)");
+        expect(outline.returnType, "");
+      }
+    });
+  }
+}
+
+
+/**
+ * Element outline kinds.
+ */
+class _OutlineKind {
+  static const _OutlineKind CLASS = const _OutlineKind('CLASS');
+  static const _OutlineKind CLASS_TYPE_ALIAS = const _OutlineKind('CLASS_TYPE_ALIAS');
+  static const _OutlineKind COMPILATION_UNIT = const _OutlineKind('COMPILATION_UNIT');
+  static const _OutlineKind CONSTRUCTOR = const _OutlineKind('CONSTRUCTOR');
+  static const _OutlineKind GETTER = const _OutlineKind('GETTER');
+  static const _OutlineKind FIELD = const _OutlineKind('FIELD');
+  static const _OutlineKind FUNCTION = const _OutlineKind('FUNCTION');
+  static const _OutlineKind FUNCTION_TYPE_ALIAS = const _OutlineKind('FUNCTION_TYPE_ALIAS');
+  static const _OutlineKind LIBRARY = const _OutlineKind('LIBRARY');
+  static const _OutlineKind METHOD = const _OutlineKind('METHOD');
+  static const _OutlineKind SETTER = const _OutlineKind('SETTER');
+  static const _OutlineKind TOP_LEVEL_VARIABLE = const _OutlineKind('TOP_LEVEL_VARIABLE');
+  static const _OutlineKind UNKNOWN = const _OutlineKind('UNKNOWN');
+  static const _OutlineKind UNIT_TEST_CASE = const _OutlineKind('UNIT_TEST_CASE');
+  static const _OutlineKind UNIT_TEST_GROUP = const _OutlineKind('UNIT_TEST_GROUP');
+
+  final String name;
+
+  const _OutlineKind(this.name);
+
+  static _OutlineKind valueOf(String name) {
+    ClassMirror classMirror = reflectClass(_OutlineKind);
+    return classMirror.getField(new Symbol(name)).reflectee;
+  }
+}
+
+
+/**
+ * An element outline.
+ */
+class _Outline {
+  static const List<_Outline> EMPTY_ARRAY = const <_Outline>[];
+
+  final _OutlineKind kind;
+  final String name;
+  final int nameOffset;
+  final int nameLength;
+  final int elementOffset;
+  final int elementLength;
+  final bool isAbstract;
+  final bool isStatic;
+  final String parameters;
+  final String returnType;
+  final List<_Outline> children = <_Outline>[];
+
+  _Outline(this.kind, this.name,
+           this.nameOffset, this.nameLength,
+           this.elementOffset, this.elementLength,
+           this.isAbstract, this.isStatic,
+           this.parameters, this.returnType);
+
+  factory _Outline.fromJson(Map<String, Object> map) {
+    _Outline outline = new _Outline(
+        _OutlineKind.valueOf(map[KIND]), map[NAME],
+        map[NAME_OFFSET], map[NAME_LENGTH],
+        map[ELEMENT_OFFSET], map[ELEMENT_LENGTH],
+        map[IS_ABSTRACT], map[IS_STATIC],
+        map[PARAMETERS], map[RETURN_TYPE]);
+    List<Map<String, Object>> childrenMaps = map[CHILDREN];
+    if (childrenMaps != null) {
+      childrenMaps.forEach((childMap) {
+        outline.children.add(new _Outline.fromJson(childMap));
+      });
+    }
+    return outline;
+  }
+}
diff --git a/pkg/http_multi_server/LICENSE b/pkg/http_multi_server/LICENSE
new file mode 100644
index 0000000..5c60afe
--- /dev/null
+++ b/pkg/http_multi_server/LICENSE
@@ -0,0 +1,26 @@
+Copyright 2014, the Dart project authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pkg/http_multi_server/README.md b/pkg/http_multi_server/README.md
new file mode 100644
index 0000000..e12c8d1
--- /dev/null
+++ b/pkg/http_multi_server/README.md
@@ -0,0 +1,25 @@
+An implementation of `dart:io`'s [HttpServer][] that wraps multiple servers and
+forwards methods to all of them. It's useful for serving the same application on
+multiple network interfaces while still having a unified way of controlling the
+servers. In particular, it supports serving on both the IPv4 and IPv6 loopback
+addresses using [HttpMultiServer.loopback][].
+
+```dart
+import 'package:http_multi_server/http_multi_server.dart';
+import 'package:shelf/shelf.dart' as shelf;
+import 'package:shelf/shelf_io.dart' as shelf_io;
+
+void main() {
+  // Both http://127.0.0.1:8080 and http://[::1]:8080 will be bound to the same
+  // server.
+  HttpMultiServer.loopback(8080).then((server) {
+    shelf_io.serveRequests(server, (request) {
+      return new shelf.Response.ok("Hello, world!");
+    });
+  });
+}
+```
+
+[HttpServer]: https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/dart-io.HttpServer
+
+[HttpMultiServer.loopback]: https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/http_multi_server/http_multi_server.HttpMultiServer#id_loopback
diff --git a/pkg/http_multi_server/lib/http_multi_server.dart b/pkg/http_multi_server/lib/http_multi_server.dart
new file mode 100644
index 0000000..c055367
--- /dev/null
+++ b/pkg/http_multi_server/lib/http_multi_server.dart
@@ -0,0 +1,136 @@
+// 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 http_multi_server;
+
+import 'dart:async';
+import 'dart:io';
+
+import 'src/utils.dart';
+
+/// An implementation of `dart:io`'s [HttpServer] that wraps multiple servers
+/// and forwards methods to all of them.
+///
+/// This is useful for serving the same application on multiple network
+/// interfaces while still having a unified way of controlling the servers. In
+/// particular, it supports serving on both the IPv4 and IPv6 loopback addresses
+/// using [HttpMultiServer.loopback].
+class HttpMultiServer extends StreamView<HttpRequest> implements HttpServer {
+  /// The wrapped servers.
+  final Set<HttpServer> _servers;
+
+  String get serverHeader => _servers.first.serverHeader;
+  set serverHeader(String value) {
+    for (var server in _servers) {
+      server.serverHeader = value;
+    }
+  }
+
+  Duration get idleTimeout => _servers.first.idleTimeout;
+  set idleTimeout(Duration value) {
+    for (var server in _servers) {
+      server.idleTimeout = value;
+    }
+  }
+
+  /// Returns the port that one of the wrapped servers is listening on.
+  ///
+  /// If the wrapped servers are listening on different ports, it's not defined
+  /// which port is returned.
+  int get port => _servers.first.port;
+
+  /// Returns the address that one of the wrapped servers is listening on.
+  ///
+  /// If the wrapped servers are listening on different addresses, it's not
+  /// defined which address is returned.
+  InternetAddress get address => _servers.first.address;
+
+  set sessionTimeout(int value) {
+    for (var server in _servers) {
+      server.sessionTimeout = value;
+    }
+  }
+
+  /// Creates an [HttpMultiServer] wrapping [servers].
+  ///
+  /// All [servers] should have the same configuration and none should be
+  /// listened to when this is called.
+  HttpMultiServer(Iterable<HttpServer> servers)
+      : _servers = servers.toSet(),
+        super(mergeStreams(servers));
+
+  /// Creates an [HttpServer] listening on all available loopback addresses for
+  /// this computer.
+  ///
+  /// If this computer supports both IPv4 and IPv6, this returns an
+  /// [HttpMultiServer] listening to [port] on both loopback addresses.
+  /// Otherwise, it returns a normal [HttpServer] listening only on the IPv4
+  /// address.
+  ///
+  /// If [port] is 0, the same ephemeral port is used for both the IPv4 and IPv6
+  /// addresses.
+  static Future<HttpServer> loopback(int port, {int backlog}) {
+    if (backlog == null) backlog = 0;
+
+    return _loopback(port, (address, port) =>
+        HttpServer.bind(address, port, backlog: backlog));
+  }
+
+  /// Like [loopback], but supports HTTPS requests.
+  ///
+  /// The certificate with nickname or distinguished name (DN) [certificateName]
+  /// is looked up in the certificate database, and is used as the server
+  /// certificate. If [requestClientCertificate] is true, the server will
+  /// request clients to authenticate with a client certificate.
+  static Future<HttpServer> loopbackSecure(int port, {int backlog,
+      String certificateName, bool requestClientCertificate: false}) {
+    if (backlog == null) backlog = 0;
+
+    return _loopback(port, (address, port) =>
+        HttpServer.bindSecure(address, port, backlog: backlog,
+            certificateName: certificateName,
+            requestClientCertificate: requestClientCertificate));
+  }
+
+  /// A helper method for initializing loopback servers.
+  ///
+  /// [bind] should forward to either [HttpServer.bind] or
+  /// [HttpServer.bindSecure].
+  static Future<HttpServer> _loopback(int port,
+      Future<HttpServer> bind(InternetAddress address, int port)) {
+    return Future.wait([
+      supportsIpV6,
+      bind(InternetAddress.LOOPBACK_IP_V4, port)
+    ]).then((results) {
+      var supportsIpV6 = results[0];
+      var v4Server = results[1];
+
+      if (!supportsIpV6) return v4Server;
+
+      // Reuse the IPv4 server's port so that if [port] is 0, both servers use
+      // the same ephemeral port.
+      return bind(InternetAddress.LOOPBACK_IP_V6, v4Server.port)
+          .then((v6Server) {
+        return new HttpMultiServer([v4Server, v6Server]);
+      });
+    });
+  }
+
+  Future close({bool force: false}) =>
+      Future.wait(_servers.map((server) => server.close(force: force)));
+
+  /// Returns an HttpConnectionsInfo object summarizing the total number of
+  /// current connections handled by all the servers.
+  HttpConnectionsInfo connectionsInfo() {
+    var info = new HttpConnectionsInfo();
+    for (var server in _servers) {
+      var subInfo = server.connectionsInfo();
+      info.total += subInfo.total;
+      info.active += subInfo.active;
+      info.idle += subInfo.idle;
+      info.closing += subInfo.closing;
+    }
+    return info;
+  }
+}
diff --git a/pkg/http_multi_server/lib/src/utils.dart b/pkg/http_multi_server/lib/src/utils.dart
new file mode 100644
index 0000000..9e95aba
--- /dev/null
+++ b/pkg/http_multi_server/lib/src/utils.dart
@@ -0,0 +1,62 @@
+// 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 http_multi_server.utils;
+
+import 'dart:async';
+import 'dart:io';
+
+/// Merges all streams in [streams] into a single stream that emits all of their
+/// values.
+///
+/// The returned stream will be closed only when every stream in [streams] is
+/// closed.
+Stream mergeStreams(Iterable<Stream> streams) {
+  var subscriptions = new Set();
+  var controller;
+  controller = new StreamController(onListen: () {
+    for (var stream in streams) {
+      var subscription;
+      subscription = stream.listen(controller.add,
+          onError: controller.addError,
+          onDone: () {
+        subscriptions.remove(subscription);
+        if (subscriptions.isEmpty) controller.close();
+      });
+      subscriptions.add(subscription);
+    }
+  }, onCancel: () {
+    for (var subscription in subscriptions) {
+      subscription.cancel();
+    }
+  }, onPause: () {
+    for (var subscription in subscriptions) {
+      subscription.pause();
+    }
+  }, onResume: () {
+    for (var subscription in subscriptions) {
+      subscription.resume();
+    }
+  }, sync: true);
+
+  return controller.stream;
+}
+
+/// A cache for [supportsIpV6].
+bool _supportsIpV6;
+
+/// Returns whether this computer supports binding to IPv6 addresses.
+Future<bool> get supportsIpV6 {
+  if (_supportsIpV6 != null) return new Future.value(_supportsIpV6);
+
+  return ServerSocket.bind(InternetAddress.LOOPBACK_IP_V6, 0).then((socket) {
+    _supportsIpV6 = true;
+    socket.close();
+    return true;
+  }).catchError((error) {
+    if (error is! SocketException) throw error;
+    _supportsIpV6 = false;
+    return false;
+  });
+}
diff --git a/pkg/http_multi_server/pubspec.yaml b/pkg/http_multi_server/pubspec.yaml
new file mode 100644
index 0000000..4199c58
--- /dev/null
+++ b/pkg/http_multi_server/pubspec.yaml
@@ -0,0 +1,11 @@
+name: http_multi_server
+version: 1.0.0
+author: "Dart Team <misc@dartlang.org>"
+homepage: http://www.dartlang.org
+description:
+  A dart:io HttpServer wrapper that handles requests from multiple servers.
+dev_dependencies:
+  unittest: ">=0.11.0 <0.12.0"
+  http: ">=0.11.0 <0.12.0"
+environment:
+  sdk: ">=1.4.0 <2.0.0"
diff --git a/pkg/http_multi_server/test/http_multi_server_test.dart b/pkg/http_multi_server/test/http_multi_server_test.dart
new file mode 100644
index 0000000..a3d9062
--- /dev/null
+++ b/pkg/http_multi_server/test/http_multi_server_test.dart
@@ -0,0 +1,128 @@
+// 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 http_multi_server.test;
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:http/http.dart' as http;
+import 'package:http_multi_server/http_multi_server.dart';
+import 'package:http_multi_server/src/utils.dart';
+import 'package:unittest/unittest.dart';
+
+void main() {
+  group("with multiple HttpServers", () {
+    var multiServer;
+    var subServer1;
+    var subServer2;
+    var subServer3;
+    setUp(() {
+      return Future.wait([
+        HttpServer.bind("127.0.0.1", 0).then((server) => subServer1 = server),
+        HttpServer.bind("127.0.0.1", 0).then((server) => subServer2 = server),
+        HttpServer.bind("127.0.0.1", 0).then((server) => subServer3 = server)
+      ]).then((servers) => multiServer = new HttpMultiServer(servers));
+    });
+
+    tearDown(() => multiServer.close());
+
+    test("listen listens to all servers", () {
+      multiServer.listen((request) {
+        request.response.write("got request");
+        request.response.close();
+      });
+
+      expect(_read(subServer1), completion(equals("got request")));
+      expect(_read(subServer2), completion(equals("got request")));
+      expect(_read(subServer3), completion(equals("got request")));
+    });
+
+    test("serverHeader= sets the value for all servers", () {
+      multiServer.serverHeader = "http_multi_server test";
+
+      multiServer.listen((request) {
+        request.response.write("got request");
+        request.response.close();
+      });
+
+      expect(_get(subServer1).then((response) {
+        expect(response.headers['server'], equals("http_multi_server test"));
+      }), completes);
+
+      expect(_get(subServer2).then((response) {
+        expect(response.headers['server'], equals("http_multi_server test"));
+      }), completes);
+
+      expect(_get(subServer3).then((response) {
+        expect(response.headers['server'], equals("http_multi_server test"));
+      }), completes);
+    });
+
+    test("connectionsInfo sums the values for all servers", () {
+      var pendingRequests = 0;
+      var awaitingResponseCompleter = new Completer();
+      var sendResponseCompleter = new Completer();
+      multiServer.listen((request) {
+        sendResponseCompleter.future.then((_) {
+          request.response.write("got request");
+          request.response.close();
+        });
+
+        pendingRequests++;
+        if (pendingRequests == 2) awaitingResponseCompleter.complete();
+      });
+
+      // Queue up some requests, then wait on [awaitingResponseCompleter] to
+      // make sure they're in-flight before we check [connectionsInfo].
+      expect(_get(subServer1), completes);
+      expect(_get(subServer2), completes);
+
+      return awaitingResponseCompleter.future.then((_) {
+        var info = multiServer.connectionsInfo();
+        expect(info.total, equals(2));
+        expect(info.active, equals(2));
+        expect(info.idle, equals(0));
+        expect(info.closing, equals(0));
+
+        sendResponseCompleter.complete();
+      });
+    });
+  });
+
+  group("HttpMultiServer.loopback", () {
+    var server;
+    setUp(() {
+      return HttpMultiServer.loopback(0).then((server_) => server = server_);
+    });
+
+    tearDown(() => server.close());
+
+    test("listens on all localhost interfaces", () {
+      server.listen((request) {
+        request.response.write("got request");
+        request.response.close();
+      });
+
+      expect(http.read("http://127.0.0.1:${server.port}/"),
+          completion(equals("got request")));
+
+      return supportsIpV6.then((supportsIpV6) {
+        if (!supportsIpV6) return;
+        expect(http.read("http://[::1]:${server.port}/"),
+            completion(equals("got request")));
+      });
+    });
+  });
+}
+
+/// Makes a GET request to the root of [server] and returns the response.
+Future<http.Response> _get(HttpServer server) => http.get(_urlFor(server));
+
+/// Makes a GET request to the root of [server] and returns the response body.
+Future<String> _read(HttpServer server) => http.read(_urlFor(server));
+
+/// Returns the URL for the root of [server].
+String _urlFor(HttpServer server) =>
+    "http://${server.address.host}:${server.port}/";
diff --git a/pkg/http_server/lib/src/http_multi_server.dart b/pkg/http_server/lib/src/http_multi_server.dart
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pkg/http_server/lib/src/http_multi_server.dart
diff --git a/pkg/json_rpc_2/test/server/stream_test.dart b/pkg/json_rpc_2/test/server/stream_test.dart
new file mode 100644
index 0000000..5459e3e
--- /dev/null
+++ b/pkg/json_rpc_2/test/server/stream_test.dart
@@ -0,0 +1,98 @@
+// 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 json_rpc_2.test.server.stream_test;
+
+import 'dart:async';
+
+import 'package:unittest/unittest.dart';
+import 'package:json_rpc_2/json_rpc_2.dart' as json_rpc;
+
+import 'utils.dart';
+
+void main() {
+  test(".withoutJson supports decoded stream and sink", () {
+    var requestController = new StreamController();
+    var responseController = new StreamController();
+    var server = new json_rpc.Server.withoutJson(
+        requestController.stream, responseController.sink);
+    server.listen();
+
+    server.registerMethod('foo', (params) {
+      return {'params': params.value};
+    });
+
+    requestController.add({
+      'jsonrpc': '2.0',
+      'method': 'foo',
+      'params': {'param': 'value'},
+      'id': 1234
+    });
+
+    expect(responseController.stream.first, completion(equals({
+      'jsonrpc': '2.0',
+      'result': {'params': {'param': 'value'}},
+      'id': 1234
+    })));
+  });
+
+  test(".listen returns when the controller is closed", () {
+    var requestController = new StreamController();
+    var responseController = new StreamController();
+    var server = new json_rpc.Server(
+        requestController.stream, responseController.sink);
+
+    var hasListenCompeted = false;
+    expect(server.listen().then((_) => hasListenCompeted = true), completes);
+
+    return pumpEventQueue().then((_) {
+      expect(hasListenCompeted, isFalse);
+
+      // This should cause listen to complete.
+      return requestController.close();
+    });
+  });
+
+  test(".listen returns a stream error", () {
+    var requestController = new StreamController();
+    var responseController = new StreamController();
+    var server = new json_rpc.Server(
+        requestController.stream, responseController.sink);
+
+    expect(server.listen(), throwsA('oh no'));
+    requestController.addError('oh no');
+  });
+
+  test(".listen can't be called twice", () {
+    var requestController = new StreamController();
+    var responseController = new StreamController();
+    var server = new json_rpc.Server(
+        requestController.stream, responseController.sink);
+    server.listen();
+
+    expect(() => server.listen(), throwsStateError);
+  });
+
+  test(".close cancels the stream subscription and closes the sink", () {
+    var requestController = new StreamController();
+    var responseController = new StreamController();
+    var server = new json_rpc.Server(
+        requestController.stream, responseController.sink);
+
+    expect(server.listen(), completes);
+    expect(server.close(), completes);
+
+    expect(() => requestController.stream.listen((_) {}), throwsStateError);
+    expect(responseController.isClosed, isTrue);
+  });
+
+  test(".close can't be called before .listen", () {
+    var requestController = new StreamController();
+    var responseController = new StreamController();
+    var server = new json_rpc.Server(
+        requestController.stream, responseController.sink);
+
+    expect(() => server.close(), throwsStateError);
+  });
+}
diff --git a/pkg/matcher/CHANGELOG.md b/pkg/matcher/CHANGELOG.md
new file mode 100644
index 0000000..98cd9f4
--- /dev/null
+++ b/pkg/matcher/CHANGELOG.md
@@ -0,0 +1,21 @@
+## 0.10.0+3
+
+* Removed `@deprecated` annotation on matchers due to 
+[Issue 19173](https://code.google.com/p/dart/issues/detail?id=19173)
+
+## 0.10.0+2
+
+* Added types to a number of constants.
+
+## 0.10.0+1
+
+* Matchers related to bad language use have been removed. These represent code
+structure that should rarely or never be validated in tests.
+    * `isAbstractClassInstantiationError`
+    * `throwsAbstractClassInstantiationError`
+    * `isFallThroughError`
+    * `throwsFallThroughError`
+
+* Added types to a number of method arguments.
+
+* The structure of the library and test code has been updated.
diff --git a/pkg/matcher/README.md b/pkg/matcher/README.md
new file mode 100644
index 0000000..cf165c1
--- /dev/null
+++ b/pkg/matcher/README.md
@@ -0,0 +1,7 @@
+Support for specifying test expectations, such as for unit tests.
+
+The matcher library provides a third-generation assertion mechanism, drawing
+inspiration from [Hamcrest](http://code.google.com/p/hamcrest/).
+
+For more information, see
+[Unit Testing with Dart](http://www.dartlang.org/articles/dart-unit-tests/).
diff --git a/pkg/matcher/lib/src/error_matchers.dart b/pkg/matcher/lib/src/error_matchers.dart
new file mode 100644
index 0000000..cb716f5
--- /dev/null
+++ b/pkg/matcher/lib/src/error_matchers.dart
@@ -0,0 +1,173 @@
+// 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.
+
+library matcher.error_matchers;
+
+import 'core_matchers.dart';
+import 'interfaces.dart';
+
+/// **DEPRECATED**
+///
+/// Will be removed in the next major release.
+// TODO(kevmoo): re-deprecate once 19173 is resolved
+//@deprecated
+const Matcher isAbstractClassInstantiationError =
+  const _AbstractClassInstantiationError();
+
+/// **DEPRECATED**
+///
+/// Will be removed in the next major release.
+// TODO(kevmoo): re-deprecate once 19173 is resolved
+//@deprecated
+const Matcher throwsAbstractClassInstantiationError =
+  const Throws(isAbstractClassInstantiationError);
+
+class _AbstractClassInstantiationError extends TypeMatcher {
+  const _AbstractClassInstantiationError() :
+  super("AbstractClassInstantiationError");
+  bool matches(item, Map matchState) => item is AbstractClassInstantiationError;
+}
+
+/// A matcher for ArgumentErrors.
+const Matcher isArgumentError = const _ArgumentError();
+
+/// A matcher for functions that throw ArgumentError.
+const Matcher throwsArgumentError = const Throws(isArgumentError);
+
+class _ArgumentError extends TypeMatcher {
+  const _ArgumentError(): super("ArgumentError");
+  bool matches(item, Map matchState) => item is ArgumentError;
+}
+
+/// A matcher for ConcurrentModificationError.
+const Matcher isConcurrentModificationError =
+    const _ConcurrentModificationError();
+
+/// A matcher for functions that throw ConcurrentModificationError.
+const Matcher throwsConcurrentModificationError =
+  const Throws(isConcurrentModificationError);
+
+class _ConcurrentModificationError extends TypeMatcher {
+  const _ConcurrentModificationError(): super("ConcurrentModificationError");
+  bool matches(item, Map matchState) => item is ConcurrentModificationError;
+}
+
+/// A matcher for CyclicInitializationError.
+const Matcher isCyclicInitializationError = const _CyclicInitializationError();
+
+/// A matcher for functions that throw CyclicInitializationError.
+const Matcher throwsCyclicInitializationError =
+  const Throws(isCyclicInitializationError);
+
+class _CyclicInitializationError extends TypeMatcher {
+  const _CyclicInitializationError(): super("CyclicInitializationError");
+  bool matches(item, Map matchState) => item is CyclicInitializationError;
+}
+
+/// A matcher for Exceptions.
+const Matcher isException = const _Exception();
+
+/// A matcher for functions that throw Exception.
+const Matcher throwsException = const Throws(isException);
+
+class _Exception extends TypeMatcher {
+  const _Exception(): super("Exception");
+  bool matches(item, Map matchState) => item is Exception;
+}
+
+/// **DEPRECATED**
+///
+/// Will be removed in the next major release.
+// TODO(kevmoo): re-deprecate once 19173 is resolved
+//@deprecated
+const Matcher isFallThroughError = const _FallThroughError();
+
+/// **DEPRECATED**
+///
+/// Will be removed in the next major release.
+// TODO(kevmoo): re-deprecate once 19173 is resolved
+//@deprecated
+const Matcher throwsFallThroughError = const Throws(isFallThroughError);
+
+class _FallThroughError extends TypeMatcher {
+  const _FallThroughError(): super("FallThroughError");
+  bool matches(item, Map matchState) => item is FallThroughError;
+}
+
+/// A matcher for FormatExceptions.
+const Matcher isFormatException = const _FormatException();
+
+/// A matcher for functions that throw FormatException.
+const Matcher throwsFormatException = const Throws(isFormatException);
+
+class _FormatException extends TypeMatcher {
+  const _FormatException(): super("FormatException");
+  bool matches(item, Map matchState) => item is FormatException;
+}
+
+/// A matcher for NoSuchMethodErrors.
+const Matcher isNoSuchMethodError = const _NoSuchMethodError();
+
+/// A matcher for functions that throw NoSuchMethodError.
+const Matcher throwsNoSuchMethodError = const Throws(isNoSuchMethodError);
+
+class _NoSuchMethodError extends TypeMatcher {
+  const _NoSuchMethodError(): super("NoSuchMethodError");
+  bool matches(item, Map matchState) => item is NoSuchMethodError;
+}
+
+/// A matcher for NullThrownError.
+const Matcher isNullThrownError = const _NullThrownError();
+
+/// A matcher for functions that throw NullThrownError.
+const Matcher throwsNullThrownError = const Throws(isNullThrownError);
+
+class _NullThrownError extends TypeMatcher {
+  const _NullThrownError(): super("NullThrownError");
+  bool matches(item, Map matchState) => item is NullThrownError;
+}
+
+/// A matcher for RangeErrors.
+const Matcher isRangeError = const _RangeError();
+
+/// A matcher for functions that throw RangeError.
+const Matcher throwsRangeError = const Throws(isRangeError);
+
+class _RangeError extends TypeMatcher {
+  const _RangeError(): super("RangeError");
+  bool matches(item, Map matchState) => item is RangeError;
+}
+
+/// A matcher for StateErrors.
+const Matcher isStateError = const _StateError();
+
+/// A matcher for functions that throw StateError.
+const Matcher throwsStateError = const Throws(isStateError);
+
+class _StateError extends TypeMatcher {
+  const _StateError(): super("StateError");
+  bool matches(item, Map matchState) => item is StateError;
+}
+
+/// A matcher for UnimplementedErrors.
+const Matcher isUnimplementedError = const _UnimplementedError();
+
+/// A matcher for functions that throw Exception.
+const Matcher throwsUnimplementedError = const Throws(isUnimplementedError);
+
+class _UnimplementedError extends TypeMatcher {
+  const _UnimplementedError(): super("UnimplementedError");
+  bool matches(item, Map matchState) => item is UnimplementedError;
+}
+
+/// A matcher for UnsupportedError.
+const Matcher isUnsupportedError = const _UnsupportedError();
+
+/// A matcher for functions that throw UnsupportedError.
+const Matcher throwsUnsupportedError = const Throws(isUnsupportedError);
+
+class _UnsupportedError extends TypeMatcher {
+  const _UnsupportedError(): super("UnsupportedError");
+  bool matches(item, Map matchState) => item is UnsupportedError;
+}
diff --git a/pkg/matcher/test/core_matchers_test.dart b/pkg/matcher/test/core_matchers_test.dart
new file mode 100644
index 0000000..3f694f3
--- /dev/null
+++ b/pkg/matcher/test/core_matchers_test.dart
@@ -0,0 +1,211 @@
+// 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.
+
+library matcher.core_matchers_test;
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('isTrue', () {
+    shouldPass(true, isTrue);
+    shouldFail(false, isTrue, "Expected: true Actual: <false>");
+  });
+
+  test('isFalse', () {
+    shouldPass(false, isFalse);
+    shouldFail(10, isFalse, "Expected: false Actual: <10>");
+    shouldFail(true, isFalse, "Expected: false Actual: <true>");
+  });
+
+  test('isNull', () {
+    shouldPass(null, isNull);
+    shouldFail(false, isNull, "Expected: null Actual: <false>");
+  });
+
+  test('isNotNull', () {
+    shouldPass(false, isNotNull);
+    shouldFail(null, isNotNull, "Expected: not null Actual: <null>");
+  });
+
+  test('same', () {
+    var a = new Map();
+    var b = new Map();
+    shouldPass(a, same(a));
+    shouldFail(b, same(a), "Expected: same instance as {} Actual: {}");
+  });
+
+  test('equals', () {
+    var a = new Map();
+    var b = new Map();
+    shouldPass(a, equals(a));
+    shouldPass(a, equals(b));
+  });
+
+  test('anything', () {
+    var a = new Map();
+    shouldPass(0, anything);
+    shouldPass(null, anything);
+    shouldPass(a, anything);
+    shouldFail(a, isNot(anything), "Expected: not anything Actual: {}");
+  });
+
+  test('throws', () {
+    shouldFail(doesNotThrow, throws,
+        matches(
+            r"Expected: throws"
+            r"  Actual: <Closure(: \(\) => dynamic "
+            r"from Function 'doesNotThrow': static\.)?>"
+            r"   Which: did not throw"));
+    shouldPass(doesThrow, throws);
+    shouldFail(true, throws,
+        "Expected: throws"
+        "  Actual: <true>"
+        "   Which: is not a Function or Future");
+  });
+
+  test('throwsA', () {
+    shouldPass(doesThrow, throwsA(equals('X')));
+    shouldFail(doesThrow, throwsA(equals('Y')),
+        matches(
+            r"Expected: throws 'Y'"
+            r"  Actual: <Closure(: \(\) => dynamic "
+            r"from Function 'doesThrow': static\.)?>"
+            r"   Which: threw 'X'"));
+  });
+
+  test('throwsA', () {
+    shouldPass(doesThrow, throwsA(equals('X')));
+    shouldFail(doesThrow, throwsA(equals('Y')),
+        matches("Expected: throws 'Y'.*"
+        "Actual: <Closure.*"
+        "Which: threw 'X'"));
+  });
+
+  test('returnsNormally', () {
+    shouldPass(doesNotThrow, returnsNormally);
+    shouldFail(doesThrow, returnsNormally,
+        matches(
+            r"Expected: return normally"
+            r"  Actual: <Closure(: \(\) => dynamic "
+            r"from Function 'doesThrow': static\.)?>"
+            r"   Which: threw 'X'"));
+  });
+
+
+  test('hasLength', () {
+    var a = new Map();
+    var b = new List();
+    shouldPass(a, hasLength(0));
+    shouldPass(b, hasLength(0));
+    shouldPass('a', hasLength(1));
+    shouldFail(0, hasLength(0), new PrefixMatcher(
+        "Expected: an object with length of <0> "
+        "Actual: <0> "
+        "Which: has no length property"));
+
+    b.add(0);
+    shouldPass(b, hasLength(1));
+    shouldFail(b, hasLength(2),
+        "Expected: an object with length of <2> "
+        "Actual: [0] "
+        "Which: has length of <1>");
+
+    b.add(0);
+    shouldFail(b, hasLength(1),
+        "Expected: an object with length of <1> "
+        "Actual: [0, 0] "
+        "Which: has length of <2>");
+    shouldPass(b, hasLength(2));
+  });
+
+  test('scalar type mismatch', () {
+    shouldFail('error', equals(5.1),
+        "Expected: <5.1> "
+        "Actual: 'error'");
+  });
+
+  test('nested type mismatch', () {
+    shouldFail(['error'], equals([5.1]),
+        "Expected: [5.1] "
+        "Actual: ['error'] "
+        "Which: was 'error' instead of <5.1> at location [0]");
+  });
+
+  test('doubly-nested type mismatch', () {
+    shouldFail([['error']], equals([[5.1]]),
+        "Expected: [[5.1]] "
+        "Actual: [['error']] "
+        "Which: was 'error' instead of <5.1> at location [0][0]");
+  });
+
+  test('doubly nested inequality', () {
+    var actual1 = [['foo', 'bar'], ['foo'], 3, []];
+    var expected1 = [['foo', 'bar'], ['foo'], 4, []];
+    var reason1 = "Expected: [['foo', 'bar'], ['foo'], 4, []] "
+        "Actual: [['foo', 'bar'], ['foo'], 3, []] "
+        "Which: was <3> instead of <4> at location [2]";
+
+    var actual2 = [['foo', 'barry'], ['foo'], 4, []];
+    var expected2 = [['foo', 'bar'], ['foo'], 4, []];
+    var reason2 = "Expected: [['foo', 'bar'], ['foo'], 4, []] "
+        "Actual: [['foo', 'barry'], ['foo'], 4, []] "
+        "Which: was 'barry' instead of 'bar' at location [0][1]";
+
+    var actual3 = [['foo', 'bar'], ['foo'], 4, {'foo':'bar'}];
+    var expected3 = [['foo', 'bar'], ['foo'], 4, {'foo':'barry'}];
+    var reason3 = "Expected: [['foo', 'bar'], ['foo'], 4, {'foo': 'barry'}] "
+        "Actual: [['foo', 'bar'], ['foo'], 4, {'foo': 'bar'}] "
+        "Which: was 'bar' instead of 'barry' at location [3]['foo']";
+
+    shouldFail(actual1, equals(expected1), reason1);
+    shouldFail(actual2, equals(expected2), reason2);
+    shouldFail(actual3, equals(expected3), reason3);
+  });
+
+  test('isInstanceOf', () {
+    shouldFail(0, new isInstanceOf<String>('String'),
+        "Expected: an instance of String Actual: <0>");
+    shouldPass('cow', new isInstanceOf<String>('String'));
+  });
+
+  group('Predicate Matchers', () {
+    test('isInstanceOf', () {
+      shouldFail(0, predicate((x) => x is String, "an instance of String"),
+          "Expected: an instance of String Actual: <0>");
+      shouldPass('cow', predicate((x) => x is String, "an instance of String"));
+    });
+  });
+
+  group('exception/error matchers', () {
+    test('throwsCyclicInitializationError', () {
+      expect(() => _Bicycle.foo, throwsCyclicInitializationError);
+    });
+
+    test('throwsConcurrentModificationError', () {
+      expect(() {
+        var a = { 'foo': 'bar' };
+        for (var k in a.keys) {
+          a.remove(k);
+        }
+      }, throwsConcurrentModificationError);
+    });
+
+    test('throwsNullThrownError', () {
+      expect(() => throw null, throwsNullThrownError);
+    });
+  });
+}
+
+class _Bicycle {
+  static final foo = bar();
+
+  static bar() {
+    return foo + 1;
+  }
+}
diff --git a/pkg/matcher/test/deprecated_matchers_test.dart b/pkg/matcher/test/deprecated_matchers_test.dart
new file mode 100644
index 0000000..b6acc1c
--- /dev/null
+++ b/pkg/matcher/test/deprecated_matchers_test.dart
@@ -0,0 +1,33 @@
+// 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.
+
+library matcher.deprecated_matchers_test;
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('throwsAbstractClassInstantiationError', () {
+    expect(() => new _AbstractClass(), throwsAbstractClassInstantiationError);
+  });
+
+  test('throwsFallThroughError', () {
+    expect(() {
+      var a = 0;
+      switch (a) {
+        case 0:
+          a += 1;
+        case 1:
+          return;
+      }
+    }, throwsFallThroughError);
+  });
+}
+
+abstract class _AbstractClass {
+}
diff --git a/pkg/matcher/test/future_matchers_test.dart b/pkg/matcher/test/future_matchers_test.dart
new file mode 100644
index 0000000..6fac0de
--- /dev/null
+++ b/pkg/matcher/test/future_matchers_test.dart
@@ -0,0 +1,76 @@
+// 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.
+
+library matcher.future_matchers_test;
+
+import 'dart:async';
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('completes - unexpected error', () {
+    var completer = new Completer();
+    completer.completeError('X');
+    shouldFail(completer.future, completes,
+        contains('Expected future to complete successfully, '
+                 'but it failed with X'),
+        isAsync: true);
+  });
+
+  test('completes - successfully', () {
+    var completer = new Completer();
+    completer.complete('1');
+    shouldPass(completer.future, completes, isAsync: true);
+  });
+
+  test('throws - unexpected to see normal completion', () {
+    var completer = new Completer();
+    completer.complete('1');
+    shouldFail(completer.future, throws,
+      contains("Expected future to fail, but succeeded with '1'"),
+      isAsync: true);
+  });
+
+  test('throws - expected to see exception', () {
+    var completer = new Completer();
+    completer.completeError('X');
+    shouldPass(completer.future, throws, isAsync: true);
+  });
+
+  test('throws - expected to see exception thrown later on', () {
+    var completer = new Completer();
+    var chained = completer.future.then((_) { throw 'X'; });
+    shouldPass(chained, throws, isAsync: true);
+    completer.complete('1');
+  });
+
+  test('throwsA - unexpected normal completion', () {
+    var completer = new Completer();
+    completer.complete('1');
+    shouldFail(completer.future, throwsA(equals('X')),
+      contains("Expected future to fail, but succeeded with '1'"),
+      isAsync: true);
+  });
+
+  test('throwsA - correct error', () {
+    var completer = new Completer();
+    completer.completeError('X');
+    shouldPass(completer.future, throwsA(equals('X')), isAsync: true);
+  });
+
+  test('throwsA - wrong error', () {
+    var completer = new Completer();
+    completer.completeError('X');
+    shouldFail(completer.future, throwsA(equals('Y')),
+        "Expected: 'Y' Actual: 'X' "
+        "Which: is different. "
+        "Expected: Y Actual: X ^ Differ at offset 0",
+        isAsync: true);
+  });
+}
diff --git a/pkg/matcher/test/iterable_matchers_test.dart b/pkg/matcher/test/iterable_matchers_test.dart
new file mode 100644
index 0000000..4570d526
--- /dev/null
+++ b/pkg/matcher/test/iterable_matchers_test.dart
@@ -0,0 +1,166 @@
+// 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.
+
+library matcher.iterable_matchers_test;
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('isEmpty', () {
+    shouldPass([], isEmpty);
+    shouldFail([1], isEmpty, "Expected: empty Actual: [1]");
+  });
+
+  test('contains', () {
+    var d = [1, 2];
+    shouldPass(d, contains(1));
+    shouldFail(d, contains(0), "Expected: contains <0> "
+        "Actual: [1, 2]");
+  });
+
+  test('equals with matcher element', () {
+    var d = ['foo', 'bar'];
+    shouldPass(d, equals(['foo', startsWith('ba')]));
+    shouldFail(d, equals(['foo', endsWith('ba')]),
+        "Expected: ['foo', <a string ending with 'ba'>] "
+        "Actual: ['foo', 'bar'] "
+        "Which: does not match a string ending with 'ba' at location [1]");
+  });
+
+  test('isIn', () {
+    var d = [1, 2];
+    shouldPass(1, isIn(d));
+    shouldFail(0, isIn(d), "Expected: is in [1, 2] Actual: <0>");
+  });
+
+  test('everyElement', () {
+    var d = [1, 2];
+    var e = [1, 1, 1];
+    shouldFail(d, everyElement(1),
+        "Expected: every element(<1>) "
+        "Actual: [1, 2] "
+        "Which: has value <2> which doesn't match <1> at index 1");
+    shouldPass(e, everyElement(1));
+  });
+
+  test('nested everyElement', () {
+    var d = [['foo', 'bar'], ['foo'], []];
+    var e = [['foo', 'bar'], ['foo'], 3, []];
+    shouldPass(d, everyElement(anyOf(isEmpty, contains('foo'))));
+    shouldFail(d, everyElement(everyElement(equals('foo'))),
+        "Expected: every element(every element('foo')) "
+        "Actual: [['foo', 'bar'], ['foo'], []] "
+        "Which: has value ['foo', 'bar'] which has value 'bar' "
+        "which is different. Expected: foo Actual: bar ^ "
+        "Differ at offset 0 at index 1 at index 0");
+    shouldFail(d, everyElement(allOf(hasLength(greaterThan(0)),
+        contains('foo'))),
+         "Expected: every element((an object with length of a value "
+         "greater than <0> and contains 'foo')) "
+         "Actual: [['foo', 'bar'], ['foo'], []] "
+         "Which: has value [] which has length of <0> at index 2");
+    shouldFail(d, everyElement(allOf(contains('foo'),
+        hasLength(greaterThan(0)))),
+        "Expected: every element((contains 'foo' and "
+        "an object with length of a value greater than <0>)) "
+        "Actual: [['foo', 'bar'], ['foo'], []] "
+        "Which: has value [] which doesn't match (contains 'foo' and "
+        "an object with length of a value greater than <0>) at index 2");
+    shouldFail(e, everyElement(allOf(contains('foo'),
+        hasLength(greaterThan(0)))),
+        "Expected: every element((contains 'foo' and an object with "
+        "length of a value greater than <0>)) "
+        "Actual: [['foo', 'bar'], ['foo'], 3, []] "
+        "Which: has value <3> which is not a string, map or iterable "
+        "at index 2");
+  });
+
+  test('anyElement', () {
+    var d = [1, 2];
+    var e = [1, 1, 1];
+    shouldPass(d, anyElement(2));
+    shouldFail(e, anyElement(2),
+        "Expected: some element <2> Actual: [1, 1, 1]");
+  });
+
+  test('orderedEquals', () {
+    shouldPass([null], orderedEquals([null]));
+    var d = [1, 2];
+    shouldPass(d, orderedEquals([1, 2]));
+    shouldFail(d, orderedEquals([2, 1]),
+        "Expected: equals [2, 1] ordered "
+        "Actual: [1, 2] "
+        "Which: was <1> instead of <2> at location [0]");
+  });
+
+  test('unorderedEquals', () {
+    var d = [1, 2];
+    shouldPass(d, unorderedEquals([2, 1]));
+    shouldFail(d, unorderedEquals([1]),
+        "Expected: equals [1] unordered "
+        "Actual: [1, 2] "
+        "Which: has too many elements (2 > 1)");
+    shouldFail(d, unorderedEquals([3, 2, 1]),
+        "Expected: equals [3, 2, 1] unordered "
+        "Actual: [1, 2] "
+        "Which: has too few elements (2 < 3)");
+    shouldFail(d, unorderedEquals([3, 1]),
+        "Expected: equals [3, 1] unordered "
+        "Actual: [1, 2] "
+        "Which: has no match for <3> at index 0");
+  });
+
+  test('unorderedMatchess', () {
+    var d = [1, 2];
+    shouldPass(d, unorderedMatches([2, 1]));
+    shouldPass(d, unorderedMatches([greaterThan(1), greaterThan(0)]));
+    shouldFail(d, unorderedMatches([greaterThan(0)]),
+        "Expected: matches [a value greater than <0>] unordered "
+        "Actual: [1, 2] "
+        "Which: has too many elements (2 > 1)");
+    shouldFail(d, unorderedMatches([3, 2, 1]),
+        "Expected: matches [<3>, <2>, <1>] unordered "
+        "Actual: [1, 2] "
+        "Which: has too few elements (2 < 3)");
+    shouldFail(d, unorderedMatches([3, 1]),
+        "Expected: matches [<3>, <1>] unordered "
+        "Actual: [1, 2] "
+        "Which: has no match for <3> at index 0");
+    shouldFail(d, unorderedMatches([greaterThan(3), greaterThan(0)]),
+        "Expected: matches [a value greater than <3>, a value greater than "
+            "<0>] unordered "
+        "Actual: [1, 2] "
+        "Which: has no match for a value greater than <3> at index 0");
+  });
+
+  test('pairwise compare', () {
+    var c = [1, 2];
+    var d = [1, 2, 3];
+    var e = [1, 4, 9];
+    shouldFail('x', pairwiseCompare(e, (e,a) => a <= e,
+        "less than or equal"),
+        "Expected: pairwise less than or equal [1, 4, 9] "
+        "Actual: 'x' "
+        "Which: is not an Iterable");
+    shouldFail(c, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"),
+        "Expected: pairwise less than or equal [1, 4, 9] "
+        "Actual: [1, 2] "
+        "Which: has length 2 instead of 3");
+    shouldPass(d, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"));
+    shouldFail(d, pairwiseCompare(e, (e,a) => a < e, "less than"),
+        "Expected: pairwise less than [1, 4, 9] "
+        "Actual: [1, 2, 3] "
+        "Which: has <1> which is not less than <1> at index 0");
+    shouldPass(d, pairwiseCompare(e, (e,a) => a * a == e, "square root of"));
+    shouldFail(d, pairwiseCompare(e, (e,a) => a + a == e, "double"),
+        "Expected: pairwise double [1, 4, 9] "
+        "Actual: [1, 2, 3] "
+        "Which: has <1> which is not double <1> at index 0");
+  });
+}
diff --git a/pkg/matcher/test/numeric_matchers_test.dart b/pkg/matcher/test/numeric_matchers_test.dart
new file mode 100644
index 0000000..60347bd
--- /dev/null
+++ b/pkg/matcher/test/numeric_matchers_test.dart
@@ -0,0 +1,152 @@
+// 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.
+
+library matcher.numeric_matchers_test;
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('greaterThan', () {
+    shouldPass(10, greaterThan(9));
+    shouldFail(9, greaterThan(10),
+      "Expected: a value greater than <10> "
+      "Actual: <9> "
+      "Which: is not a value greater than <10>");
+  });
+
+  test('greaterThanOrEqualTo', () {
+    shouldPass(10, greaterThanOrEqualTo(10));
+    shouldFail(9, greaterThanOrEqualTo(10),
+      "Expected: a value greater than or equal to <10> "
+      "Actual: <9> "
+      "Which: is not a value greater than or equal to <10>");
+  });
+
+  test('lessThan', () {
+    shouldFail(10, lessThan(9),
+        "Expected: a value less than <9> "
+        "Actual: <10> "
+        "Which: is not a value less than <9>");
+    shouldPass(9, lessThan(10));
+  });
+
+  test('lessThanOrEqualTo', () {
+    shouldPass(10, lessThanOrEqualTo(10));
+    shouldFail(11, lessThanOrEqualTo(10),
+      "Expected: a value less than or equal to <10> "
+      "Actual: <11> "
+      "Which: is not a value less than or equal to <10>");
+  });
+
+  test('isZero', () {
+    shouldPass(0, isZero);
+    shouldFail(1, isZero,
+        "Expected: a value equal to <0> "
+        "Actual: <1> "
+        "Which: is not a value equal to <0>");
+  });
+
+  test('isNonZero', () {
+    shouldFail(0, isNonZero,
+        "Expected: a value not equal to <0> "
+        "Actual: <0> "
+        "Which: is not a value not equal to <0>");
+    shouldPass(1, isNonZero);
+  });
+
+  test('isPositive', () {
+    shouldFail(-1, isPositive,
+        "Expected: a positive value "
+        "Actual: <-1> "
+        "Which: is not a positive value");
+    shouldFail(0, isPositive,
+        "Expected: a positive value "
+        "Actual: <0> "
+        "Which: is not a positive value");
+    shouldPass(1, isPositive);
+  });
+
+  test('isNegative', () {
+    shouldPass(-1, isNegative);
+    shouldFail(0, isNegative,
+        "Expected: a negative value "
+        "Actual: <0> "
+        "Which: is not a negative value");
+  });
+
+  test('isNonPositive', () {
+    shouldPass(-1, isNonPositive);
+    shouldPass(0, isNonPositive);
+    shouldFail(1, isNonPositive,
+        "Expected: a non-positive value "
+        "Actual: <1> "
+        "Which: is not a non-positive value");
+  });
+
+  test('isNonNegative', () {
+    shouldPass(1, isNonNegative);
+    shouldPass(0, isNonNegative);
+    shouldFail(-1, isNonNegative,
+      "Expected: a non-negative value "
+      "Actual: <-1> "
+      "Which: is not a non-negative value");
+  });
+
+  test('closeTo', () {
+    shouldPass(0, closeTo(0, 1));
+    shouldPass(-1, closeTo(0, 1));
+    shouldPass(1, closeTo(0, 1));
+    shouldFail(1.001, closeTo(0, 1),
+        "Expected: a numeric value within <1> of <0> "
+        "Actual: <1.001> "
+        "Which: differs by <1.001>");
+    shouldFail(-1.001, closeTo(0, 1),
+        "Expected: a numeric value within <1> of <0> "
+        "Actual: <-1.001> "
+        "Which: differs by <1.001>");
+  });
+
+  test('inInclusiveRange', () {
+    shouldFail(-1, inInclusiveRange(0,2),
+        "Expected: be in range from 0 (inclusive) to 2 (inclusive) "
+        "Actual: <-1>");
+    shouldPass(0, inInclusiveRange(0,2));
+    shouldPass(1, inInclusiveRange(0,2));
+    shouldPass(2, inInclusiveRange(0,2));
+    shouldFail(3, inInclusiveRange(0,2),
+        "Expected: be in range from 0 (inclusive) to 2 (inclusive) "
+        "Actual: <3>");
+  });
+
+  test('inExclusiveRange', () {
+    shouldFail(0, inExclusiveRange(0,2),
+        "Expected: be in range from 0 (exclusive) to 2 (exclusive) "
+        "Actual: <0>");
+    shouldPass(1, inExclusiveRange(0,2));
+    shouldFail(2, inExclusiveRange(0,2),
+        "Expected: be in range from 0 (exclusive) to 2 (exclusive) "
+        "Actual: <2>");
+  });
+
+  test('inOpenClosedRange', () {
+    shouldFail(0, inOpenClosedRange(0,2),
+        "Expected: be in range from 0 (exclusive) to 2 (inclusive) "
+        "Actual: <0>");
+    shouldPass(1, inOpenClosedRange(0,2));
+    shouldPass(2, inOpenClosedRange(0,2));
+  });
+
+  test('inClosedOpenRange', () {
+    shouldPass(0, inClosedOpenRange(0,2));
+    shouldPass(1, inClosedOpenRange(0,2));
+    shouldFail(2, inClosedOpenRange(0,2),
+        "Expected: be in range from 0 (inclusive) to 2 (exclusive) "
+        "Actual: <2>");
+  });
+}
diff --git a/pkg/matcher/test/operator_matchers_test.dart b/pkg/matcher/test/operator_matchers_test.dart
new file mode 100644
index 0000000..fd9627a
--- /dev/null
+++ b/pkg/matcher/test/operator_matchers_test.dart
@@ -0,0 +1,28 @@
+// 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.
+
+library matcher.operator_matchers_test;
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('anyOf', () {
+    shouldFail(0, anyOf([equals(1), equals(2)]),
+        "Expected: (<1> or <2>) Actual: <0>");
+    shouldPass(1, anyOf([equals(1), equals(2)]));
+  });
+
+  test('allOf', () {
+    shouldPass(1, allOf([lessThan(10), greaterThan(0)]));
+    shouldFail(-1, allOf([lessThan(10), greaterThan(0)]),
+        "Expected: (a value less than <10> and a value greater than <0>) "
+        "Actual: <-1> "
+        "Which: is not a value greater than <0>");
+  });
+}
diff --git a/pkg/matcher/test/string_matchers_test.dart b/pkg/matcher/test/string_matchers_test.dart
new file mode 100644
index 0000000..1303641
--- /dev/null
+++ b/pkg/matcher/test/string_matchers_test.dart
@@ -0,0 +1,94 @@
+// 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.
+
+library matcher.string_matchers_test;
+
+import 'package:matcher/matcher.dart';
+import 'package:unittest/unittest.dart' show test, group;
+
+import 'test_utils.dart';
+
+void main() {
+  initUtils();
+
+  test('collapseWhitespace', () {
+    var source = '\t\r\n hello\t\r\n world\r\t \n';
+    expect(collapseWhitespace(source), 'hello world');
+  });
+
+  test('isEmpty', () {
+    shouldPass('', isEmpty);
+    shouldFail(null, isEmpty, "Expected: empty Actual: <null>");
+    shouldFail(0, isEmpty, "Expected: empty Actual: <0>");
+    shouldFail('a', isEmpty, "Expected: empty Actual: 'a'");
+  });
+
+  test('equalsIgnoringCase', () {
+    shouldPass('hello', equalsIgnoringCase('HELLO'));
+    shouldFail('hi', equalsIgnoringCase('HELLO'),
+        "Expected: 'HELLO' ignoring case Actual: 'hi'");
+  });
+
+  test('equalsIgnoringWhitespace', () {
+    shouldPass(' hello   world  ', equalsIgnoringWhitespace('hello world'));
+    shouldFail(' helloworld  ', equalsIgnoringWhitespace('hello world'),
+        "Expected: 'hello world' ignoring whitespace "
+        "Actual: ' helloworld ' "
+        "Which: is 'helloworld' with whitespace compressed");
+  });
+
+  test('startsWith', () {
+    shouldPass('hello', startsWith(''));
+    shouldPass('hello', startsWith('hell'));
+    shouldPass('hello', startsWith('hello'));
+    shouldFail('hello', startsWith('hello '),
+        "Expected: a string starting with 'hello ' "
+        "Actual: 'hello'");
+  });
+
+  test('endsWith', () {
+    shouldPass('hello', endsWith(''));
+    shouldPass('hello', endsWith('lo'));
+    shouldPass('hello', endsWith('hello'));
+    shouldFail('hello', endsWith(' hello'),
+        "Expected: a string ending with ' hello' "
+        "Actual: 'hello'");
+  });
+
+  test('contains', () {
+    shouldPass('hello', contains(''));
+    shouldPass('hello', contains('h'));
+    shouldPass('hello', contains('o'));
+    shouldPass('hello', contains('hell'));
+    shouldPass('hello', contains('hello'));
+    shouldFail('hello', contains(' '),
+        "Expected: contains ' ' Actual: 'hello'");
+  });
+
+  test('stringContainsInOrder', () {
+    shouldPass('goodbye cruel world', stringContainsInOrder(['']));
+    shouldPass('goodbye cruel world', stringContainsInOrder(['goodbye']));
+    shouldPass('goodbye cruel world', stringContainsInOrder(['cruel']));
+    shouldPass('goodbye cruel world', stringContainsInOrder(['world']));
+    shouldPass('goodbye cruel world',
+               stringContainsInOrder(['good', 'bye', 'world']));
+    shouldPass('goodbye cruel world',
+               stringContainsInOrder(['goodbye', 'cruel']));
+    shouldPass('goodbye cruel world',
+               stringContainsInOrder(['cruel', 'world']));
+    shouldPass('goodbye cruel world',
+      stringContainsInOrder(['goodbye', 'cruel', 'world']));
+    shouldFail('goodbye cruel world',
+      stringContainsInOrder(['goo', 'cruel', 'bye']),
+      "Expected: a string containing 'goo', 'cruel', 'bye' in order "
+      "Actual: 'goodbye cruel world'");
+  });
+
+  test('matches', () {
+    shouldPass('c0d', matches('[a-z][0-9][a-z]'));
+    shouldPass('c0d', matches(new RegExp('[a-z][0-9][a-z]')));
+    shouldFail('cOd', matches('[a-z][0-9][a-z]'),
+        "Expected: match '[a-z][0-9][a-z]' Actual: 'cOd'");
+  });
+}
diff --git a/pkg/polymer/lib/auto_binding.dart b/pkg/polymer/lib/auto_binding.dart
new file mode 100644
index 0000000..44dc1ca
--- /dev/null
+++ b/pkg/polymer/lib/auto_binding.dart
@@ -0,0 +1,117 @@
+// 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 polymer.auto_binding;
+
+import 'dart:html';
+import 'package:polymer/polymer.dart';
+import 'package:template_binding/template_binding.dart';
+
+/**
+ * The `d-auto-binding` element extends the template element. It provides a
+ * quick and easy way to do data binding without the need to setup a binding
+ * delegate or use the [templateBind] call. Both data and event handlers can be
+ * bound using the [model].
+ *
+ * The `d-auto-binding` element acts just like a template that is bound to
+ * a model. It stamps its content in the dom adjacent to itself. When the
+ * content is stamped, the `template-bound` event is fired.
+ *
+ * Example:
+ *
+ *     <template is="d-auto-binding">
+ *       <div>Say something: <input value="{{value}}"></div>
+ *       <div>You said: {{value}}</div>
+ *       <button on-tap="{{buttonTap}}">Tap me!</button>
+ *     </template>
+ *     <script type="application/dart">
+ *       import 'dart:html';
+ *       import 'package:polymer/polymer.dart';
+ *
+ *       main() {
+ *         var template = document.querySelector('template');
+ *         template.model = new MyModel();
+ *       }
+ *
+ *       class MyModel {
+ *         String value = 'something';
+ *         buttonTap() => console.log('tap!');
+ *       }
+ *     </script>
+ *
+ */
+// Dart note: renamed to d-auto-binding to avoid conflict with JS auto-binding.
+class AutoBindingElement extends TemplateElement with Polymer, Observable
+    implements TemplateBindExtension {
+
+  /// Make template_binding "extension methods" friendly.
+  /// Note that [NodeBindExtension] is already implemented by [Polymer].
+  TemplateBindExtension _self;
+
+  get model => _self.model;
+  set model(value) { _self.model = value; }
+
+  BindingDelegate get bindingDelegate => _self.bindingDelegate;
+  set bindingDelegate(BindingDelegate value) { _self.bindingDelegate = value; }
+
+  void clear() => _self.clear();
+
+  @override
+  PolymerExpressions get syntax => bindingDelegate;
+
+  AutoBindingElement.created() : super.created() {
+    polymerCreated();
+
+    _self = templateBindFallback(this);
+
+    bindingDelegate = makeSyntax();
+
+    // delay stamping until polymer-ready so that auto-binding is not
+    // required to load last.
+    Polymer.onReady.then((_) {
+      attributes['bind'] = '';
+      // we don't bother with an explicit signal here, we could ust a MO
+      // if necessary
+      async((_) {
+        // note: this will marshall *all* the elements in the parentNode
+        // rather than just stamped ones. We'd need to use createInstance
+        // to fix this or something else fancier.
+        marshalNodeReferences(parentNode);
+        // template stamping is asynchronous so stamping isn't complete
+        // by polymer-ready; fire an event so users can use stamped elements
+        fire('template-bound');
+      });
+    });
+  }
+
+  PolymerExpressions makeSyntax() => new _AutoBindingSyntax(this);
+
+  DocumentFragment createInstance([model, BindingDelegate delegate]) =>
+      _self.createInstance(model, delegate);
+}
+
+// Dart note: this is implemented a little differently to keep it in classic
+// OOP style. Instead of monkeypatching findController, we override
+// getEventHandler to do the right thing.
+class _AutoBindingSyntax extends PolymerExpressions {
+  final AutoBindingElement _node;
+
+  _AutoBindingSyntax(this._node) : super();
+
+  EventListener getEventHandler(controller, target, String method) => (e) {
+    if (controller == null || controller is! Polymer) controller = _node;
+
+    if (controller is Polymer) {
+      var args = [e, e.detail, e.currentTarget];
+
+      // Dart note: make sure we dispatch to the model, not the
+      // AutoBindingElement instance.
+      var obj = controller == _node ? _node.model : controller;
+      controller.dispatchMethod(obj, method, args);
+    } else {
+      throw new StateError('controller $controller is not a '
+          'Dart polymer-element.');
+    }
+  };
+}
diff --git a/pkg/polymer/lib/src/events.dart b/pkg/polymer/lib/src/events.dart
new file mode 100644
index 0000000..503445f
--- /dev/null
+++ b/pkg/polymer/lib/src/events.dart
@@ -0,0 +1,149 @@
+// Copyright (c) 2013, 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.
+
+/// Code from declaration/events.js
+part of polymer;
+
+/// An extension of [polymer_expressions.PolymerExpressions] that adds support
+/// for binding events using `on-eventName` using [PolymerEventBindings].
+// TODO(jmesserly): the JS layering is a bit odd, with polymer-dev implementing
+// events and polymer-expressions implementing everything else. I don't think
+// this separation is right in the long term, so we're using the same class name
+// until we can sort it out.
+class PolymerExpressions extends BindingDelegate with PolymerEventBindings {
+
+  /// A wrapper around polymer_expressions used to implement forwarding.
+  /// Ideally we would inherit from it, but mixins can't be applied to a type
+  /// that forwards to a superclass with a constructor that has optional or
+  /// named arguments.
+  final BindingDelegate _delegate;
+
+  PolymerExpressions({Map<String, Object> globals})
+      : _delegate = new polymer_expressions.PolymerExpressions(
+          globals: globals);
+
+  prepareBinding(String path, name, node) {
+    if (_hasEventPrefix(name)) {
+      return prepareEventBinding(path, name, node);
+    }
+    return _delegate.prepareBinding(path, name, node);
+  }
+
+  prepareInstanceModel(Element template) =>
+      _delegate.prepareInstanceModel(template);
+
+  prepareInstancePositionChanged(Element template) =>
+      _delegate.prepareInstancePositionChanged(template);
+}
+
+/// A mixin for a [BindingDelegate] to add Polymer event support.
+/// This is included in [PolymerExpressions].
+abstract class PolymerEventBindings {
+  /// Finds the event controller for this node.
+  Element findController(Node node) {
+    while (node.parentNode != null) {
+      if (node is Polymer && node.eventController != null) {
+        return node.eventController;
+      }
+      node = node.parentNode;
+    }
+    return node is ShadowRoot ? node.host : null;
+  }
+
+  EventListener getEventHandler(controller, target, String method) => (e) {
+    if (controller == null || controller is! Polymer) {
+      controller = findController(target);
+    }
+
+    if (controller is Polymer) {
+      var args = [e, e.detail, e.currentTarget];
+      controller.dispatchMethod(controller, method, args);
+    } else {
+      throw new StateError('controller $controller is not a '
+          'Dart polymer-element.');
+    }
+  };
+
+  prepareEventBinding(String path, String name, Node node) {
+    if (!_hasEventPrefix(name)) return null;
+
+    var eventType = _removeEventPrefix(name);
+    var translated = _eventTranslations[eventType];
+    eventType = translated != null ? translated : eventType;
+
+    return (model, node, oneTime) {
+      var handler = getEventHandler(null, node, path);
+      node.addEventListener(eventType, handler);
+
+      if (oneTime) return null;
+      return new _EventBindable(node, eventType, handler, path);
+    };
+  }
+}
+
+
+class _EventBindable extends Bindable {
+  final Node _node;
+  final String _eventType;
+  final Function _handler;
+  final String _path;
+
+  _EventBindable(this._node, this._eventType, this._handler, this._path);
+
+  // TODO(rafaelw): This is really pointless work. Aside from the cost
+  // of these allocations, NodeBind is going to setAttribute back to its
+  // current value. Fixing this would mean changing the TemplateBinding
+  // binding delegate API.
+  get value => '{{ $_path }}';
+
+  open(callback) => value;
+
+  void close() => _node.removeEventListener(_eventType, _handler);
+}
+
+
+/// Attribute prefix used for declarative event handlers.
+const _EVENT_PREFIX = 'on-';
+
+/// Whether an attribute declares an event.
+bool _hasEventPrefix(String attr) => attr.startsWith(_EVENT_PREFIX);
+
+String _removeEventPrefix(String name) => name.substring(_EVENT_PREFIX.length);
+
+// Dart note: polymer.js calls this mixedCaseEventTypes. But we have additional
+// things that need translation due to renames.
+final _eventTranslations = const {
+  'domfocusout': 'DOMFocusOut',
+  'domfocusin': 'DOMFocusIn',
+  'dommousescroll': 'DOMMouseScroll',
+
+  // Dart note: handle Dart-specific event names.
+  'animationend': 'webkitAnimationEnd',
+  'animationiteration': 'webkitAnimationIteration',
+  'animationstart': 'webkitAnimationStart',
+  'doubleclick': 'dblclick',
+  'fullscreenchange': 'webkitfullscreenchange',
+  'fullscreenerror': 'webkitfullscreenerror',
+  'keyadded': 'webkitkeyadded',
+  'keyerror': 'webkitkeyerror',
+  'keymessage': 'webkitkeymessage',
+  'needkey': 'webkitneedkey',
+  'speechchange': 'webkitSpeechChange',
+};
+
+final _reverseEventTranslations = () {
+  final map = new Map<String, String>();
+  _eventTranslations.forEach((onName, eventType) {
+    map[eventType] = onName;
+  });
+  return map;
+}();
+
+// Dart note: we need this function because we have additional renames JS does
+// not have. The JS renames are simply case differences, whereas we have ones
+// like doubleclick -> dblclick and stripping the webkit prefix.
+String _eventNameFromType(String eventType) {
+  final result = _reverseEventTranslations[eventType];
+  return result != null ? result : eventType;
+}
diff --git a/pkg/polymer/lib/src/js/polymer/layout.html b/pkg/polymer/lib/src/js/polymer/layout.html
new file mode 100644
index 0000000..4e1284b
--- /dev/null
+++ b/pkg/polymer/lib/src/js/polymer/layout.html
@@ -0,0 +1,278 @@
+<!--
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<style shim-shadowdom>
+/*******************************
+          Flex Layout
+*******************************/
+
+html /deep/ [layout][horizontal], html /deep/ [layout][vertical] {
+  display: -ms-flexbox;
+  display: -webkit-flex;
+  display: flex;
+}
+
+html /deep/ [layout][horizontal][inline], html /deep/ [layout][vertical][inline] {
+  display: -ms-inline-flexbox;
+  display: -webkit-inline-flex;
+  display: inline-flex;
+}
+
+html /deep/ [layout][horizontal] {
+  -ms-flex-direction: row;
+  -webkit-flex-direction: row;
+  flex-direction: row;
+}
+
+html /deep/ [layout][horizontal][reverse] {
+  -ms-flex-direction: row-reverse;
+  -webkit-flex-direction: row-reverse;
+  flex-direction: row-reverse;
+}
+
+html /deep/ [layout][vertical] {
+  -ms-flex-direction: column;
+  -webkit-flex-direction: column;
+  flex-direction: column;
+}
+
+html /deep/ [layout][vertical][reverse] {
+  -ms-flex-direction: column-reverse;
+  -webkit-flex-direction: column-reverse;
+  flex-direction: column-reverse;
+}
+
+html /deep/ [layout][wrap] {
+  -ms-flex-wrap: wrap;
+  -webkit-flex-wrap: wrap;
+  flex-wrap: wrap;
+}
+
+html /deep/ [layout][wrap-reverse] {
+  -ms-flex-wrap: wrap-reverse;
+  -webkit-flex-wrap: wrap-reverse;
+  flex-wrap: wrap-reverse;
+}
+
+html /deep/ [flex] {
+  -ms-flex: 1;
+  -webkit-flex: 1;
+  flex: 1;
+}
+
+html /deep/ [flex][auto] {
+  -ms-flex: 1 1 auto;
+  -webkit-flex: 1 1 auto;
+  flex: 1 1 auto;
+}
+
+html /deep/ [flex][none] {
+  -ms-flex: none;
+  -webkit-flex: none;
+  flex: none;
+}
+
+html /deep/ [flex][one] {
+  -ms-flex: 1;
+  -webkit-flex: 1;
+  flex: 1;
+}
+
+html /deep/ [flex][two] {
+  -ms-flex: 2;
+  -webkit-flex: 2;
+  flex: 2;
+}
+
+html /deep/ [flex][three] {
+  -ms-flex: 3;
+  -webkit-flex: 3;
+  flex: 3;
+}
+
+html /deep/ [flex][four] {
+  -ms-flex: 4;
+  -webkit-flex: 4;
+  flex: 4;
+}
+
+html /deep/ [flex][five] {
+  -ms-flex: 5;
+  -webkit-flex: 5;
+  flex: 5;
+}
+
+html /deep/ [flex][six] {
+  -ms-flex: 6;
+  -webkit-flex: 6;
+  flex: 6;
+}
+
+html /deep/ [flex][seven] {
+  -ms-flex: 7;
+  -webkit-flex: 7;
+  flex: 7;
+}
+
+html /deep/ [flex][eight] {
+  -ms-flex: 8;
+  -webkit-flex: 8;
+  flex: 8;
+}
+
+html /deep/ [flex][nine] {
+  -ms-flex: 9;
+  -webkit-flex: 9;
+  flex: 9;
+}
+
+html /deep/ [flex][ten] {
+  -ms-flex: 10;
+  -webkit-flex: 10;
+  flex: 10;
+}
+
+html /deep/ [flex][eleven] {
+  -ms-flex: 11;
+  -webkit-flex: 11;
+  flex: 11;
+}
+
+html /deep/ [flex][twelve] {
+  -ms-flex: 12;
+  -webkit-flex: 12;
+  flex: 12;
+}
+
+/* alignment in cross axis */
+
+html /deep/ [layout][start] {
+  -ms-flex-align: start;
+  -webkit-align-items: flex-start;
+  align-items: flex-start;
+}
+
+html /deep/ [layout][center] {
+  -ms-flex-align: center;
+  -webkit-align-items: center;
+  align-items: center;
+}
+
+html /deep/ [layout][end] {
+  -ms-flex-align: end;
+  -webkit-align-items: flex-end;
+  align-items: flex-end;
+}
+
+/* alignment in main axis */
+
+html /deep/ [layout][start-justified] {
+  -ms-flex-pack: start;
+  -webkit-justify-content: flex-start;
+  justify-content: flex-start;
+}
+
+html /deep/ [layout][center-justified] {
+  -ms-flex-pack: center;
+  -webkit-justify-content: center;
+  justify-content: center;
+}
+
+html /deep/ [layout][end-justified] {
+  -ms-flex-pack: end;
+  -webkit-justify-content: flex-end;
+  justify-content: flex-end;
+}
+
+html /deep/ [layout][around-justified] {
+  -ms-flex-pack: around;
+  -webkit-justify-content: space-around;
+  justify-content: space-around;
+}
+
+html /deep/ [layout][justified] {
+  -ms-flex-pack: justify;
+  -webkit-justify-content: space-between;
+  justify-content: space-between;
+}
+
+/* self alignment */
+
+html /deep/ [self-start] {
+  -ms-align-self: flex-start;
+  -webkit-align-self: flex-start;
+  align-self: flex-start;
+}
+
+html /deep/ [self-center] {
+  -ms-align-self: center;
+  -webkit-align-self: center;
+  align-self: center;
+}
+
+html /deep/ [self-end] {
+  -ms-align-self: flex-end;
+  -webkit-align-self: flex-end;
+  align-self: flex-end;
+}
+
+html /deep/ [self-stretch] {
+  -ms-align-self: stretch;
+  -webkit-align-self: stretch;
+  align-self: stretch;
+}
+
+/*******************************
+          Other Layout
+*******************************/
+
+html /deep/ [block] {
+  display: block;
+}
+
+/* ie support for hidden */
+html /deep/ [hidden] {
+  display: none;
+}
+
+html /deep/ [relative] {
+  position: relative;
+}
+
+html /deep/ [fit] {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+}
+
+body[fullbleed] {
+  margin: 0;
+  height: 100vh;
+}
+
+/*******************************
+            Other
+*******************************/
+
+html /deep/ [segment], html /deep/ segment {
+  display: block;
+  position: relative;
+  -webkit-box-sizing: border-box;
+  -ms-box-sizing: border-box;
+  box-sizing: border-box;
+  margin: 1em 0.5em;
+  padding: 1em;
+  background-color: white;
+  -webkit-box-shadow: 0px 0px 0px 1px rgba(0, 0, 0, 0.1);
+  box-shadow: 0px 0px 0px 1px rgba(0, 0, 0, 0.1);
+  border-radius: 5px 5px 5px 5px;
+}
+
+</style>
\ No newline at end of file
diff --git a/pkg/polymer/test/auto_binding_test.dart b/pkg/polymer/test/auto_binding_test.dart
new file mode 100644
index 0000000..b563814
--- /dev/null
+++ b/pkg/polymer/test/auto_binding_test.dart
@@ -0,0 +1,47 @@
+// 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.
+
+import 'dart:async';
+import 'dart:html';
+import 'package:polymer/auto_binding.dart';
+import 'package:polymer/polymer.dart';
+import 'package:unittest/unittest.dart';
+import 'package:unittest/html_config.dart';
+
+class TestModel {
+  var greeting = 'Hi';
+  eventAction(e) {
+    e.detail.add('handled');
+  }
+}
+
+main() => initPolymer().run(() {
+  useHtmlConfiguration();
+
+  setUp(() => Polymer.onReady);
+
+  test('elements upgraded', () {
+    AutoBindingElement template = document.getElementById('one');
+    template.model = new TestModel();
+
+    var completer = new Completer();
+    var events = 0;
+    window.addEventListener('template-bound', (e) {
+      events++;
+      if (e.target.id == 'one') {
+        expect(e.target, template);
+
+        var t = template;
+        var h = t.$['h'];
+        expect(h.text, t.model.greeting, reason: 'binding applied');
+        var ce = t.fire('tap', onNode: h, detail: []);
+        expect(ce.detail, ['handled'], reason: 'element event handler fired');
+      }
+
+      if (events == 2) completer.complete();
+    });
+
+    return completer.future;
+  });
+});
diff --git a/pkg/polymer/test/auto_binding_test.html b/pkg/polymer/test/auto_binding_test.html
new file mode 100644
index 0000000..822d290
--- /dev/null
+++ b/pkg/polymer/test/auto_binding_test.html
@@ -0,0 +1,32 @@
+<!doctype html>
+<!--
+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.
+-->
+<html>
+  <head>
+  <!--polymer-test: this comment is needed for test_suite.dart-->
+    <title>auto-binding test</title>
+    <link rel="import" href="packages/polymer/polymer.html">
+    <script src="/root_dart/tools/testing/dart/test_controller.js"></script>
+  </head>
+  <body unresolved>
+
+    <div>top</div>
+
+    <template id="one" is="d-auto-binding">
+      <h2 id="h" on-tap="{{eventAction}}">{{greeting}}</h2>
+    </template>
+
+    <template id="two" is="d-auto-binding">
+      <div>Say something: <input value="{{value}}"></div>
+      <div>You said: {{value}}</div>
+    </template>
+
+    <div>bottom</div>
+
+    <script type="application/dart" src="auto_binding_test.dart"></script>
+
+  </body>
+</html>
diff --git a/runtime/bin/net/os_windows.c b/runtime/bin/net/os_windows.c
new file mode 100644
index 0000000..07ccdc5
--- /dev/null
+++ b/runtime/bin/net/os_windows.c
@@ -0,0 +1,11 @@
+// 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.
+
+#if !defined(_MSC_VER)
+#error "This file should only be compiled under MSVC"
+#endif
+
+#if defined(_X86_)
+#include "../../../third_party/nss/nss/lib/freebl/mpi/mpi_x86_asm.c"
+#endif
diff --git a/runtime/bin/vmservice/client/deployed/web/packages/observatory/src/elements/class_tree.html b/runtime/bin/vmservice/client/deployed/web/packages/observatory/src/elements/class_tree.html
new file mode 100644
index 0000000..8ede1e6
--- /dev/null
+++ b/runtime/bin/vmservice/client/deployed/web/packages/observatory/src/elements/class_tree.html
@@ -0,0 +1,119 @@
+<link rel="import" href="nav_bar.html">
+<link rel="import" href="observatory_element.html">
+<link rel="import" href="class_ref.html">
+
+<polymer-element name="class-tree" extends="observatory-element">
+  <template>
+    <link rel="stylesheet" href="css/shared.css">
+    <style>
+      .table {
+        border-collapse: collapse!important;
+        width: 100%;
+        margin-bottom: 20px
+      }
+      .table thead > tr > th,
+      .table tbody > tr > th,
+      .table tfoot > tr > th,
+      .table thead > tr > td,
+      .table tbody > tr > td,
+      .table tfoot > tr > td {
+        padding: 8px;
+        vertical-align: top;
+      }
+      .table thead > tr > th {
+        vertical-align: bottom;
+        text-align: left;
+        border-bottom:2px solid #ddd;
+      }
+
+      tr:hover > td {
+        background-color: #FFF3E3;
+      }
+      .rowColor0 {
+        background-color: #FFE9CC;
+      }
+      .rowColor1 {
+        background-color: #FFDEB2;
+      }
+      .rowColor2 {
+        background-color: #FFD399;
+      }
+      .rowColor3 {
+        background-color: #FFC87F;
+      }
+      .rowColor4 {
+        background-color: #FFBD66;
+      }
+      .rowColor5 {
+        background-color: #FFB24C;
+      }
+      .rowColor6 {
+        background-color: #FFA733;
+      }
+      .rowColor7 {
+        background-color: #FF9C19;
+      }
+      .rowColor8 {
+        background-color: #FF9100;
+      }
+
+      .tooltip {
+        display: block;
+        position: absolute;
+        visibility: hidden;
+        opacity: 0;
+        transition: visibility 0s linear 0.5s;
+        transition: opacity .4s ease-in-out;
+      }
+
+      tr:hover .tooltip {
+        display: block;
+        position: absolute;
+        top: 100%;
+        right: 100%;
+        visibility: visible;
+        z-index: 999;
+        width: 400px;
+        color: #ffffff;
+        background-color: #0489c3;
+        border-top-right-radius: 8px;
+        border-top-left-radius: 8px;
+        border-bottom-right-radius: 8px;
+        border-bottom-left-radius: 8px;
+        transition: visibility 0s linear 0.5s;
+        transition: opacity .4s ease-in-out;
+        opacity: 1;
+      }
+
+      .white {
+        color: #ffffff;
+      }
+    </style>
+    <nav-bar>
+      <top-nav-menu last="{{ true }}"></top-nav-menu>
+      <nav-control></nav-control>
+    </nav-bar>
+    <div class="content-centered">
+      <h1>Class Hierarchy</h1>
+      <table id="tableTree" class="table">
+        <thead>
+          <tr>
+            <th>Class</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr template repeat="{{row in tree.rows }}">
+            <td on-click="{{toggleExpanded}}"
+                class="{{ coloring(row) }}"
+                style="{{ padding(row) }}">
+              <span id="expand" style="{{ row.expanderStyle }}">{{ row.expander }}</span>
+              <class-ref ref="{{ row.cls }}"></class-ref>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  </template>
+</polymer-element>
+
+<script type="application/dart" src="class_tree.dart"></script>
diff --git a/runtime/bin/vmservice/client/lib/src/elements/class_tree.dart b/runtime/bin/vmservice/client/lib/src/elements/class_tree.dart
new file mode 100644
index 0000000..aeb29fa
--- /dev/null
+++ b/runtime/bin/vmservice/client/lib/src/elements/class_tree.dart
@@ -0,0 +1,113 @@
+// 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 class_tree_element;
+
+import 'observatory_element.dart';
+import 'dart:html';
+import 'package:logging/logging.dart';
+import 'package:observatory/app.dart';
+import 'package:observatory/service.dart';
+import 'package:polymer/polymer.dart';
+
+class ClassTreeRow extends TableTreeRow {
+  @reflectable final Isolate isolate;
+  @reflectable final Class cls;
+  ClassTreeRow(this.isolate, this.cls, ClassTreeRow parent) : super(parent) {
+    assert(isolate != null);
+    assert(cls != null);
+  }
+
+  void onShow() {
+    if (children.length > 0) {
+      // Child rows already created.
+      return;
+    }
+    for (var subClass in cls.children) {
+      if (subClass.isPatch) {
+        continue;
+      }
+      var row = new ClassTreeRow(isolate, subClass, this);
+      children.add(row);
+    }
+  }
+
+  void onHide() {
+  }
+
+  bool hasChildren() {
+    return cls.children.length > 0;
+  }
+}
+
+
+@CustomTag('class-tree')
+class ClassTreeElement extends ObservatoryElement {
+  @observable Isolate isolate;
+
+  TableTree tree;
+
+  ClassTreeElement.created() : super.created();
+
+  void enteredView() {
+    tree = new TableTree();
+    if (isolate != null) {
+      _update(isolate.objectClass);
+    }
+  }
+
+  isolateChanged(oldValue) {
+    isolate.getClassHierarchy().then((objectClass) {
+      _update(objectClass);
+    });
+  }
+
+  void _update(Class root) {
+    try {
+      var rootRow = new ClassTreeRow(isolate, root, null);
+      rootRow.children.add(new ClassTreeRow(isolate, root, rootRow));
+      tree.initialize(rootRow);
+    } catch (e, stackTrace) {
+      Logger.root.warning('_update', e, stackTrace);
+    }
+    // Check if we only have one node at the root and expand it.
+    if (tree.rows.length == 1) {
+      tree.toggle(0);
+    }
+    notifyPropertyChange(#tree, null, tree);
+  }
+
+  @observable String padding(TableTreeRow row) {
+    return 'padding-left: ${row.depth * 16}px;';
+  }
+
+  @observable String coloring(TableTreeRow row) {
+    const colors = const ['rowColor0', 'rowColor1', 'rowColor2', 'rowColor3',
+                          'rowColor4', 'rowColor5', 'rowColor6', 'rowColor7',
+                          'rowColor8'];
+    var index = (row.depth - 1) % colors.length;
+    return colors[index];
+  }
+
+  @observable void toggleExpanded(Event e, var detail, Element target) {
+    // We only want to expand a tree row if the target of the click is
+    // the table cell (passed in as target) or the span containing the
+    // expander symbol (#expand).
+    var eventTarget = e.target;
+    if ((eventTarget.id != 'expand') && (e.target != target)) {
+      // Target of click was not the expander span or the table cell.
+      return;
+    }
+    var row = target.parent;
+    if (row is TableRowElement) {
+      try {
+        // Subtract 1 to get 0 based indexing.
+        tree.toggle(row.rowIndex - 1);
+      }  catch (e, stackTrace) {
+        Logger.root.warning('toggleExpanded', e, stackTrace);
+      }
+    }
+  }
+
+}
diff --git a/runtime/bin/vmservice/client/lib/src/elements/class_tree.html b/runtime/bin/vmservice/client/lib/src/elements/class_tree.html
new file mode 100644
index 0000000..8ede1e6
--- /dev/null
+++ b/runtime/bin/vmservice/client/lib/src/elements/class_tree.html
@@ -0,0 +1,119 @@
+<link rel="import" href="nav_bar.html">
+<link rel="import" href="observatory_element.html">
+<link rel="import" href="class_ref.html">
+
+<polymer-element name="class-tree" extends="observatory-element">
+  <template>
+    <link rel="stylesheet" href="css/shared.css">
+    <style>
+      .table {
+        border-collapse: collapse!important;
+        width: 100%;
+        margin-bottom: 20px
+      }
+      .table thead > tr > th,
+      .table tbody > tr > th,
+      .table tfoot > tr > th,
+      .table thead > tr > td,
+      .table tbody > tr > td,
+      .table tfoot > tr > td {
+        padding: 8px;
+        vertical-align: top;
+      }
+      .table thead > tr > th {
+        vertical-align: bottom;
+        text-align: left;
+        border-bottom:2px solid #ddd;
+      }
+
+      tr:hover > td {
+        background-color: #FFF3E3;
+      }
+      .rowColor0 {
+        background-color: #FFE9CC;
+      }
+      .rowColor1 {
+        background-color: #FFDEB2;
+      }
+      .rowColor2 {
+        background-color: #FFD399;
+      }
+      .rowColor3 {
+        background-color: #FFC87F;
+      }
+      .rowColor4 {
+        background-color: #FFBD66;
+      }
+      .rowColor5 {
+        background-color: #FFB24C;
+      }
+      .rowColor6 {
+        background-color: #FFA733;
+      }
+      .rowColor7 {
+        background-color: #FF9C19;
+      }
+      .rowColor8 {
+        background-color: #FF9100;
+      }
+
+      .tooltip {
+        display: block;
+        position: absolute;
+        visibility: hidden;
+        opacity: 0;
+        transition: visibility 0s linear 0.5s;
+        transition: opacity .4s ease-in-out;
+      }
+
+      tr:hover .tooltip {
+        display: block;
+        position: absolute;
+        top: 100%;
+        right: 100%;
+        visibility: visible;
+        z-index: 999;
+        width: 400px;
+        color: #ffffff;
+        background-color: #0489c3;
+        border-top-right-radius: 8px;
+        border-top-left-radius: 8px;
+        border-bottom-right-radius: 8px;
+        border-bottom-left-radius: 8px;
+        transition: visibility 0s linear 0.5s;
+        transition: opacity .4s ease-in-out;
+        opacity: 1;
+      }
+
+      .white {
+        color: #ffffff;
+      }
+    </style>
+    <nav-bar>
+      <top-nav-menu last="{{ true }}"></top-nav-menu>
+      <nav-control></nav-control>
+    </nav-bar>
+    <div class="content-centered">
+      <h1>Class Hierarchy</h1>
+      <table id="tableTree" class="table">
+        <thead>
+          <tr>
+            <th>Class</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr template repeat="{{row in tree.rows }}">
+            <td on-click="{{toggleExpanded}}"
+                class="{{ coloring(row) }}"
+                style="{{ padding(row) }}">
+              <span id="expand" style="{{ row.expanderStyle }}">{{ row.expander }}</span>
+              <class-ref ref="{{ row.cls }}"></class-ref>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  </template>
+</polymer-element>
+
+<script type="application/dart" src="class_tree.dart"></script>
diff --git a/runtime/vm/code_generator.cc b/runtime/vm/code_generator.cc
index 417a905..72706ac 100644
--- a/runtime/vm/code_generator.cc
+++ b/runtime/vm/code_generator.cc
@@ -633,12 +633,10 @@
     caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   }
   if (FLAG_trace_patching) {
-    OS::PrintErr("PatchStaticCall: patching caller pc %#" Px ""
-        " to '%s' new entry point %#" Px " (%s)\n",
+    OS::PrintErr("PatchStaticCall: patching from %#" Px " to '%s' %#" Px "\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
-        target_code.EntryPoint(),
-        target_code.is_optimized() ? "optimized" : "unoptimized");
+        target_code.EntryPoint());
   }
   arguments.SetReturn(target_code);
 }
@@ -1295,11 +1293,9 @@
     caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
   }
   if (FLAG_trace_patching) {
-    OS::PrintErr("FixCallersTarget: caller %#" Px " "
-        "target '%s' %#" Px " -> %#" Px "\n",
+    OS::PrintErr("FixCallersTarget: patching from %#" Px " to '%s' %#" Px "\n",
         frame->pc(),
         target_function.ToFullyQualifiedCString(),
-        target_code.EntryPoint(),
         current_target_code.EntryPoint());
   }
   arguments.SetReturn(current_target_code);
diff --git a/runtime/vm/compiler.cc b/runtime/vm/compiler.cc
index b8805f8..da3feb1 100644
--- a/runtime/vm/compiler.cc
+++ b/runtime/vm/compiler.cc
@@ -59,7 +59,6 @@
     "Enable compiler verification assertions");
 
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
-DECLARE_FLAG(bool, trace_patching);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 DECLARE_FLAG(bool, warning_as_error);
 
@@ -557,12 +556,8 @@
         if (optimized) {
           if (osr_id == Isolate::kNoDeoptId) {
             CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
-            if (FLAG_trace_compiler || FLAG_trace_patching) {
-              if (FLAG_trace_compiler) {
-                OS::Print("  ");
-              }
-              OS::Print("Patch unoptimized '%s' entry point %#" Px "\n",
-                  function.ToFullyQualifiedCString(),
+            if (FLAG_trace_compiler) {
+              OS::Print("--> patching entry %#" Px "\n",
                   Code::Handle(function.unoptimized_code()).EntryPoint());
             }
           }
@@ -580,10 +575,11 @@
           ASSERT(CodePatcher::CodeIsPatchable(code));
         }
         if (parsed_function->HasDeferredPrefixes()) {
-          ZoneGrowableArray<const LibraryPrefix*>* prefixes =
-              parsed_function->deferred_prefixes();
-          for (intptr_t i = 0; i < prefixes->length(); i++) {
-            (*prefixes)[i]->RegisterDependentCode(code);
+          GrowableObjectArray* prefixes = parsed_function->DeferredPrefixes();
+          LibraryPrefix& prefix = LibraryPrefix::Handle();
+          for (intptr_t i = 0; i < prefixes->Length(); i++) {
+            prefix ^= prefixes->At(i);
+            prefix.RegisterDependentCode(code);
           }
         }
       }
diff --git a/runtime/vm/flow_graph.cc b/runtime/vm/flow_graph.cc
index c0c74a6..afaffa1 100644
--- a/runtime/vm/flow_graph.cc
+++ b/runtime/vm/flow_graph.cc
@@ -42,8 +42,7 @@
     use_far_branches_(false),
     loop_headers_(NULL),
     loop_invariant_loads_(NULL),
-    guarded_fields_(builder.guarded_fields()),
-    deferred_prefixes_(builder.deferred_prefixes()) {
+    guarded_fields_(builder.guarded_fields()) {
   DiscoverBlocks();
 }
 
@@ -64,21 +63,6 @@
 }
 
 
-void FlowGraph::AddToDeferredPrefixes(
-    ZoneGrowableArray<const LibraryPrefix*>* from) {
-  ZoneGrowableArray<const LibraryPrefix*>* to = deferred_prefixes();
-  for (intptr_t i = 0; i < from->length(); i++) {
-    const  LibraryPrefix* prefix = (*from)[i];
-    for (intptr_t j = 0; j < to->length(); j++) {
-      if ((*to)[j]->raw() == prefix->raw()) {
-        return;
-      }
-    }
-    to->Add(prefix);
-  }
-}
-
-
 bool FlowGraph::ShouldReorderBlocks(const Function& function,
                                     bool is_optimized) {
   return is_optimized && FLAG_reorder_basic_blocks && !function.is_intrinsic();
diff --git a/runtime/vm/flow_graph.h b/runtime/vm/flow_graph.h
index 1868d0a..9d2d42e 100644
--- a/runtime/vm/flow_graph.h
+++ b/runtime/vm/flow_graph.h
@@ -216,16 +216,11 @@
 
   static void AddToGuardedFields(ZoneGrowableArray<const Field*>* array,
                                  const Field* field);
-  void AddToDeferredPrefixes(ZoneGrowableArray<const LibraryPrefix*>* from);
 
   ZoneGrowableArray<const Field*>* guarded_fields() const {
     return guarded_fields_;
   }
 
-  ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes() const {
-    return deferred_prefixes_;
-  }
-
  private:
   friend class IfConverter;
   friend class BranchSimplifier;
@@ -305,7 +300,6 @@
   ZoneGrowableArray<BlockEntryInstr*>* loop_headers_;
   ZoneGrowableArray<BitVector*>* loop_invariant_loads_;
   ZoneGrowableArray<const Field*>* guarded_fields_;
-  ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes_;
 };
 
 
diff --git a/runtime/vm/flow_graph_builder.h b/runtime/vm/flow_graph_builder.h
index 8467cb5..7632971 100644
--- a/runtime/vm/flow_graph_builder.h
+++ b/runtime/vm/flow_graph_builder.h
@@ -199,10 +199,6 @@
     return guarded_fields_;
   }
 
-  ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes() const {
-    return parsed_function_->deferred_prefixes();
-  }
-
   intptr_t temp_count() const { return temp_count_; }
   intptr_t AllocateTemp() { return temp_count_++; }
   void DeallocateTemps(intptr_t count) {
diff --git a/runtime/vm/flow_graph_inliner.cc b/runtime/vm/flow_graph_inliner.cc
index 11fedc1..b07c635 100644
--- a/runtime/vm/flow_graph_inliner.cc
+++ b/runtime/vm/flow_graph_inliner.cc
@@ -802,9 +802,6 @@
         FlowGraph::AddToGuardedFields(caller_graph_->guarded_fields(),
                                       (*callee_graph->guarded_fields())[i]);
       }
-      // When inlined, we add the deferred prefixes of the callee to the
-      // caller's list of deferred prefixes.
-      caller_graph()->AddToDeferredPrefixes(callee_graph->deferred_prefixes());
 
       // We allocate a ZoneHandle for the unoptimized code so that it cannot be
       // disconnected from its function during the rest of compilation.
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index cc02d9a..2f9559b 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -2523,13 +2523,6 @@
         if (!CodePatcher::IsEntryPatched(code)) {
           CodePatcher::PatchEntry(code);
         }
-      } else if (!function.HasCode() && (code.GetEntryPatchPc() != 0)) {
-        // The code has already been disconnected, make it invalid. Do not
-        // bother with OSR compiled code that has no valid entry-patch.
-        ReportSwitchingCode(code);
-        if (!CodePatcher::IsEntryPatched(code)) {
-          CodePatcher::PatchEntry(code);
-        }
       }
     }
   }
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index c41e5c1..8667c20 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -135,12 +135,16 @@
 void ParsedFunction::AddDeferredPrefix(const LibraryPrefix& prefix) {
   ASSERT(prefix.is_deferred_load());
   ASSERT(!prefix.is_loaded());
-  for (intptr_t i = 0; i < deferred_prefixes_->length(); i++) {
-    if ((*deferred_prefixes_)[i]->raw() == prefix.raw()) {
+  if (deferred_prefixes_ == NULL) {
+    deferred_prefixes_ =
+        &GrowableObjectArray::ZoneHandle(GrowableObjectArray::New());
+  }
+  for (intptr_t i = 0; i < deferred_prefixes_->Length(); i++) {
+    if (deferred_prefixes_->At(i) == prefix.raw()) {
       return;
     }
   }
-  deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(I, prefix.raw()));
+  deferred_prefixes_->Add(prefix);
 }
 
 
diff --git a/runtime/vm/parser.h b/runtime/vm/parser.h
index 15de41f..f187032 100644
--- a/runtime/vm/parser.h
+++ b/runtime/vm/parser.h
@@ -47,7 +47,7 @@
         saved_current_context_var_(NULL),
         saved_entry_context_var_(NULL),
         expression_temp_var_(NULL),
-        deferred_prefixes_(new ZoneGrowableArray<const LibraryPrefix*>()),
+        deferred_prefixes_(NULL),
         first_parameter_index_(0),
         first_stack_local_index_(0),
         num_copied_params_(0),
@@ -110,10 +110,8 @@
   static LocalVariable* CreateExpressionTempVar(intptr_t token_pos);
   LocalVariable* EnsureExpressionTemp();
 
-  bool HasDeferredPrefixes() const { return deferred_prefixes_->length() != 0; }
-  ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes() const {
-    return deferred_prefixes_;
-  }
+  bool HasDeferredPrefixes() const { return deferred_prefixes_ != NULL; }
+  GrowableObjectArray* DeferredPrefixes() const { return deferred_prefixes_; }
   void AddDeferredPrefix(const LibraryPrefix& prefix);
 
   int first_parameter_index() const { return first_parameter_index_; }
@@ -134,7 +132,7 @@
   LocalVariable* saved_current_context_var_;
   LocalVariable* saved_entry_context_var_;
   LocalVariable* expression_temp_var_;
-  ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes_;
+  GrowableObjectArray* deferred_prefixes_;
 
   int first_parameter_index_;
   int first_stack_local_index_;
diff --git a/sdk/lib/internal/lru.dart b/sdk/lib/internal/lru.dart
new file mode 100644
index 0000000..8f8a64a
--- /dev/null
+++ b/sdk/lib/internal/lru.dart
@@ -0,0 +1,125 @@
+// 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.
+
+part of dart._internal;
+
+class LRUAssociation<K,V> {
+  K key;
+  V value;
+  LRUAssociation previous;
+  LRUAssociation next;
+
+  void insertBetween(before, after) {
+    after.previous = this;
+    before.next = this;
+    this.next = after;
+    this.previous = before;
+  }
+
+  void remove() {
+    var after = next;
+    var before = previous;
+    after.previous = before;
+    before.next = after;
+  }
+}
+
+/**
+ * A map with a fixed capacity that evicts associations when capacity is reached
+ * on a least-recently-used basis. Implemented as an open addressing hash table
+ * with doubly-linked entries forming the LRU queue.
+ */
+class LRUMap<K,V> {
+  final LRUAssociation<K,V> _head;
+  final List _table;
+  final int _mask;
+  final int _capacity;  // Max number of associations before we start evicting.
+  int _size = 0;  // Current number of associations.
+
+  /**
+   * Create an LRUMap whose capacity is 75% of 2^shift.
+   */
+  LRUMap.withShift(int shift)
+      : this._mask = (1 << shift) - 1
+      , this._capacity = (1 << shift) * 3 ~/ 4
+      , this._table = new List(1 << shift)
+      , this._head = new LRUAssociation() {
+    // The scheme used here for handling collisions relies on there always
+    // being at least one empty slot.
+    if (shift < 1) throw new Exception("LRUMap requires a shift >= 1");
+    assert(_table.length > _capacity);
+    _head.insertBetween(_head, _head);
+  }
+
+  int _scanFor(K key) {
+    var start = key.hashCode & _mask;
+    var index = start;
+    do {
+      var assoc = _table[index];
+      if (null == assoc || assoc.key == key) {
+        return index;
+      }
+      index = (index + 1) & _mask;
+    } while (index != start);
+    // Should never happen because we start evicting associations before the
+    // table is full.
+    throw new Exception("Internal error: LRUMap table full");
+  }
+
+  void _fixCollisionsAfter(start) {
+    var assoc;
+    var index = (start + 1) & _mask;
+    while (null != (assoc = _table[index])) {
+      var newIndex = _scanFor(assoc.key);
+      if (newIndex != index) {
+        assert(_table[newIndex] == null);
+        _table[newIndex] = assoc;
+        _table[index] = null;
+      }
+      index = (index + 1) & _mask;
+    }
+  }
+
+  operator []=(K key, V value) {
+    int index = _scanFor(key);
+    var assoc = _table[index];
+    if (null != assoc) {
+      // Existing key, replace value.
+      assert(assoc.key == key);
+      assoc.value = value;
+      assoc.remove();
+      assoc.insertBetween(_head, _head.next);
+    } else {
+      // New key.
+      var newAssoc;
+      if (_size == _capacity) {
+        // Knock out the oldest association.
+        var lru = _head.previous;
+        lru.remove();
+        index = _scanFor(lru.key);
+        _table[index] = null;
+        _fixCollisionsAfter(index);
+        index = _scanFor(key);
+        newAssoc = lru;  // Recycle the association.
+      } else {
+        newAssoc = new LRUAssociation();
+        _size++;
+      }
+      newAssoc.key = key;
+      newAssoc.value = value;
+      newAssoc.insertBetween(_head, _head.next);
+      _table[index] = newAssoc;
+    }
+  }
+
+  V operator [](K key) {
+    var index = _scanFor(key);
+    var assoc = _table[index];
+    if (null == assoc) return null;
+    // Move to front of LRU queue.
+    assoc.remove();
+    assoc.insertBetween(_head, _head.next);
+    return assoc.value;
+  }
+}
diff --git a/tests/lib/mirrors/lru_test.dart b/tests/lib/mirrors/lru_test.dart
new file mode 100644
index 0000000..141fc98
--- /dev/null
+++ b/tests/lib/mirrors/lru_test.dart
@@ -0,0 +1,34 @@
+// 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.
+
+import "dart:mirrors";
+import "package:expect/expect.dart";
+
+newLRUMapWithShift(int shift) {
+  var lib = currentMirrorSystem().libraries[Uri.parse("dart:_internal")];
+  var cls = lib.declarations[#LRUMap];
+  return cls.newInstance(#withShift, [shift]).reflectee;
+}
+
+main() {
+  Expect.throws(() => newLRUMapWithShift(0), (e) => e is Exception);
+
+  for (int shift = 1; shift < 5; shift++) {
+    var map = newLRUMapWithShift(shift);
+    var capacity = (1 << shift) * 3 ~/ 4;
+    for (int value = 0; value < 100; value++) {
+      var key = "$value";
+      map[key] = value;
+      Expect.equals(value, map[key]);
+    }
+    for (int value = 0; value < 100 - capacity - 1; value++) {
+      var key = "$value";
+      Expect.equals(null, map[key]);
+    }
+    for (int value = 100 - capacity; value < 100; value++) {
+      var key = "$value";
+      Expect.equals(value, map[key]);
+    }
+  }
+}
\ No newline at end of file
diff --git a/tools/VERSION b/tools/VERSION
index dbc0a4a..cd798b5c 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -28,4 +28,4 @@
 MINOR 5
 PATCH 0
 PRERELEASE 4
-PRERELEASE_PATCH 3
+PRERELEASE_PATCH 4