anchor.diff:  }
   
   class CompletionResults {
  -  static CompletionResults parse(Map m) => new CompletionResults(m['id'], m['replacementOffset'], m['replacementLength'], m['results'] == null ? null : new List.from(m['results'].map((obj) => CompletionSuggestion.parse(obj))), m['isLast']);
  +  static CompletionResults parse(Map m) => new CompletionResults(
  +      m['id'],
  +      m['replacementOffset'],
  +      m['replacementLength'],
  +      m['results'] == null
  +          ? null
  +          : new List.from(
  +              m['results'].map((obj) => CompletionSuggestion.parse(obj))),
  +      m['isLast']);
   
     final String id;
     final int replacementOffset;
  
positive.code:   SearchDomain(Server server) : super(server, 'search');
  
    Stream<SearchResults> get onResults {
      return _listen('search.results', SearchResults.parse) as Stream<SearchResults>;
    }
  
    Future<FindElementReferencesResult> findElementReferences(String file, int offset, bool includePotential) {
      Map m = {'file': file, 'offset': offset, 'includePotential': includePotential};
      return _call('search.findElementReferences', m).then(FindElementReferencesResult.parse);
    }
  
    Future<FindMemberDeclarationsResult> findMemberDeclarations(String name) {
      Map m = {'name': name};
      return _call('search.findMemberDeclarations', m).then(FindMemberDeclarationsResult.parse);
    }
  
    Future<FindMemberReferencesResult> findMemberReferences(String name) {
      Map m = {'name': name};
      return _call('search.findMemberReferences', m).then(FindMemberReferencesResult.parse);
    }
  
    Future<FindTopLevelDeclarationsResult> findTopLevelDeclarations(String pattern) {
      Map m = {'pattern': pattern};
      return _call('search.findTopLevelDeclarations', m).then(FindTopLevelDeclarationsResult.parse);
    }
  
    Future<TypeHierarchyResult> getTypeHierarchy(String file, int offset, {bool superOnly}) {
      Map m = {'file': file, 'offset': offset};
      if (superOnly != null) m['superOnly'] = superOnly;
      return _call('search.getTypeHierarchy', m).then(TypeHierarchyResult.parse);
  
negative.code: }
  
  class RefactoringResult {
    static RefactoringResult parse(Map m) => new RefactoringResult(
        m['initialProblems'] == null
            ? null
            : new List.from(
                m['initialProblems'].map((obj) => RefactoringProblem.parse(obj))),
        m['optionsProblems'] == null
            ? null
            : new List.from(
                m['optionsProblems'].map((obj) => RefactoringProblem.parse(obj))),
        m['finalProblems'] == null
            ? null
            : new List.from(
                m['finalProblems'].map((obj) => RefactoringProblem.parse(obj))),
        feedback: RefactoringFeedback.parse(m['feedback']),
        change: SourceChange.parse(m['change']),
        potentialEdits: m['potentialEdits'] == null
            ? null
            : new List.from(m['potentialEdits']));
  
    final List<RefactoringProblem> initialProblems;
    final List<RefactoringProblem> optionsProblems;
    final List<RefactoringProblem> finalProblems;
    @optional
    final RefactoringFeedback feedback;
    @optional
    final SourceChange change;
    @optional
    final List<String> potentialEdits;
  
    RefactoringResult(
        this.initialProblems, this.optionsProblems, this.finalProblems,
        {this.feedback, this.change, this.potentialEdits});
  }
  
  class StatementCompletionResult {
    static StatementCompletionResult parse(Map m) =>
        new StatementCompletionResult(
            SourceChange.parse(m['change']), m['whitespaceOnly']);
  
    final SourceChange change;
    final bool whitespaceOnly;
  