Fix code generated matchers to handle recursive objects.

pkg/analysis_server/test/integration/protocol_matchers.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/spec/generate_files".
 
 /**
  * Matchers for data types defined in the analysis server API
@@ skipping 10 matching lines @@
  */
 final Matcher isServerGetVersionParams = isNull;
 
 /**
  * server.getVersion result
  *
  * {
  *   "version": String
  * }
  */
-final Matcher isServerGetVersionResult = new MatchesJsonObject(
+final Matcher isServerGetVersionResult = new LazyMatcher(() => new MatchesJsonObject(
   "server.getVersion result", {
     "version": isString
-  });
+  }));
 
 /**
  * server.shutdown params
  */
 final Matcher isServerShutdownParams = isNull;
 
 /**
  * server.shutdown result
  */
 final Matcher isServerShutdownResult = isNull;
 
 /**
  * server.setSubscriptions params
  *
  * {
  *   "subscriptions": List<ServerService>
  * }
  */
-final Matcher isServerSetSubscriptionsParams = new MatchesJsonObject(
+final Matcher isServerSetSubscriptionsParams = new LazyMatcher(() => new MatchesJsonObject(
   "server.setSubscriptions params", {
     "subscriptions": isListOf(isServerService)
-  });
+  }));
 
 /**
  * server.setSubscriptions result
  */
 final Matcher isServerSetSubscriptionsResult = isNull;
 
 /**
  * server.connected params
  */
 final Matcher isServerConnectedParams = isNull;
 
 /**
  * server.error params
  *
  * {
  *   "fatal": bool
  *   "message": String
  *   "stackTrace": String
  * }
  */
-final Matcher isServerErrorParams = new MatchesJsonObject(
+final Matcher isServerErrorParams = new LazyMatcher(() => new MatchesJsonObject(
   "server.error params", {
     "fatal": isBool,
     "message": isString,
     "stackTrace": isString
-  });
+  }));
 
 /**
  * server.status params
  *
  * {
  *   "analysis": optional AnalysisStatus
  * }
  */
-final Matcher isServerStatusParams = new MatchesJsonObject(
+final Matcher isServerStatusParams = new LazyMatcher(() => new MatchesJsonObject(
   "server.status params", null, optionalFields: {
     "analysis": isAnalysisStatus
-  });
+  }));
 
 /**
  * analysis.getErrors params
  *
  * {
  *   "file": FilePath
  * }
  */
-final Matcher isAnalysisGetErrorsParams = new MatchesJsonObject(
+final Matcher isAnalysisGetErrorsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.getErrors params", {
     "file": isFilePath
-  });
+  }));
 
 /**
  * analysis.getErrors result
  *
  * {
  *   "errors": List<AnalysisError>
  * }
  */
-final Matcher isAnalysisGetErrorsResult = new MatchesJsonObject(
+final Matcher isAnalysisGetErrorsResult = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.getErrors result", {
     "errors": isListOf(isAnalysisError)
-  });
+  }));
 
 /**
  * analysis.getHover params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-final Matcher isAnalysisGetHoverParams = new MatchesJsonObject(
+final Matcher isAnalysisGetHoverParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.getHover params", {
     "file": isFilePath,
     "offset": isInt
-  });
+  }));
 
 /**
  * analysis.getHover result
  *
  * {
  *   "hovers": List<HoverInformation>
  * }
  */
-final Matcher isAnalysisGetHoverResult = new MatchesJsonObject(
+final Matcher isAnalysisGetHoverResult = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.getHover result", {
     "hovers": isListOf(isHoverInformation)
-  });
+  }));
 
 /**
  * analysis.reanalyze params
  */
 final Matcher isAnalysisReanalyzeParams = isNull;
 
 /**
  * analysis.reanalyze result
  */
 final Matcher isAnalysisReanalyzeResult = isNull;
 
 /**
  * analysis.setAnalysisRoots params
  *
  * {
  *   "included": List<FilePath>
  *   "excluded": List<FilePath>
  * }
  */
-final Matcher isAnalysisSetAnalysisRootsParams = new MatchesJsonObject(
+final Matcher isAnalysisSetAnalysisRootsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.setAnalysisRoots params", {
     "included": isListOf(isFilePath),
     "excluded": isListOf(isFilePath)
-  });
+  }));
 
 /**
  * analysis.setAnalysisRoots result
  */
 final Matcher isAnalysisSetAnalysisRootsResult = isNull;
 
 /**
  * analysis.setPriorityFiles params
  *
  * {
  *   "files": List<FilePath>
  * }
  */
-final Matcher isAnalysisSetPriorityFilesParams = new MatchesJsonObject(
+final Matcher isAnalysisSetPriorityFilesParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.setPriorityFiles params", {
     "files": isListOf(isFilePath)
-  });
+  }));
 
 /**
  * analysis.setPriorityFiles result
  */
 final Matcher isAnalysisSetPriorityFilesResult = isNull;
 
 /**
  * analysis.setSubscriptions params
  *
  * {
  *   "subscriptions": Map<AnalysisService, List<FilePath>>
  * }
  */
-final Matcher isAnalysisSetSubscriptionsParams = new MatchesJsonObject(
+final Matcher isAnalysisSetSubscriptionsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.setSubscriptions params", {
     "subscriptions": isMapOf(isAnalysisService, isListOf(isFilePath))
-  });
+  }));
 
 /**
  * analysis.setSubscriptions result
  */
 final Matcher isAnalysisSetSubscriptionsResult = isNull;
 
 /**
  * analysis.updateContent params
  *
  * {
  *   "files": Map<FilePath, AddContentOverlay | ChangeContentOverlay | RemoveContentOverlay>
  * }
  */
-final Matcher isAnalysisUpdateContentParams = new MatchesJsonObject(
+final Matcher isAnalysisUpdateContentParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.updateContent params", {
     "files": isMapOf(isFilePath, isOneOf([isAddContentOverlay, isChangeContentOverlay, isRemoveContentOverlay]))
-  });
+  }));
 
 /**
  * analysis.updateContent result
  */
 final Matcher isAnalysisUpdateContentResult = isNull;
 
 /**
  * analysis.updateOptions params
  *
  * {
  *   "options": AnalysisOptions
  * }
  */
-final Matcher isAnalysisUpdateOptionsParams = new MatchesJsonObject(
+final Matcher isAnalysisUpdateOptionsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.updateOptions params", {
     "options": isAnalysisOptions
-  });
+  }));
 
 /**
  * analysis.updateOptions result
  */
 final Matcher isAnalysisUpdateOptionsResult = isNull;
 
 /**
  * analysis.errors params
  *
  * {
  *   "file": FilePath
  *   "errors": List<AnalysisError>
  * }
  */
-final Matcher isAnalysisErrorsParams = new MatchesJsonObject(
+final Matcher isAnalysisErrorsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.errors params", {
     "file": isFilePath,
     "errors": isListOf(isAnalysisError)
-  });
+  }));
 
 /**
  * analysis.flushResults params
  *
  * {
  *   "files": List<FilePath>
  * }
  */
-final Matcher isAnalysisFlushResultsParams = new MatchesJsonObject(
+final Matcher isAnalysisFlushResultsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.flushResults params", {
     "files": isListOf(isFilePath)
-  });
+  }));
 
 /**
  * analysis.folding params
  *
  * {
  *   "file": FilePath
  *   "regions": List<FoldingRegion>
  * }
  */
-final Matcher isAnalysisFoldingParams = new MatchesJsonObject(
+final Matcher isAnalysisFoldingParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.folding params", {
     "file": isFilePath,
     "regions": isListOf(isFoldingRegion)
-  });
+  }));
 
 /**
  * analysis.highlights params
  *
  * {
  *   "file": FilePath
  *   "regions": List<HighlightRegion>
  * }
  */
-final Matcher isAnalysisHighlightsParams = new MatchesJsonObject(
+final Matcher isAnalysisHighlightsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.highlights params", {
     "file": isFilePath,
     "regions": isListOf(isHighlightRegion)
-  });
+  }));
 
 /**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
  *   "regions": List<NavigationRegion>
  * }
  */
-final Matcher isAnalysisNavigationParams = new MatchesJsonObject(
+final Matcher isAnalysisNavigationParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.navigation params", {
     "file": isFilePath,
     "regions": isListOf(isNavigationRegion)
-  });
+  }));
 
 /**
  * analysis.occurrences params
  *
  * {
  *   "file": FilePath
  *   "occurrences": List<Occurrences>
  * }
  */
-final Matcher isAnalysisOccurrencesParams = new MatchesJsonObject(
+final Matcher isAnalysisOccurrencesParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.occurrences params", {
     "file": isFilePath,
     "occurrences": isListOf(isOccurrences)
-  });
+  }));
 
 /**
  * analysis.outline params
  *
  * {
  *   "file": FilePath
  *   "outline": Outline
  * }
  */
-final Matcher isAnalysisOutlineParams = new MatchesJsonObject(
+final Matcher isAnalysisOutlineParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.outline params", {
     "file": isFilePath,
     "outline": isOutline
-  });
+  }));
 
 /**
  * analysis.overrides params
  *
  * {
  *   "file": FilePath
  *   "overrides": List<Override>
  * }
  */
-final Matcher isAnalysisOverridesParams = new MatchesJsonObject(
+final Matcher isAnalysisOverridesParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.overrides params", {
     "file": isFilePath,
     "overrides": isListOf(isOverride)
-  });
+  }));
 
 /**
  * completion.getSuggestions params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-final Matcher isCompletionGetSuggestionsParams = new MatchesJsonObject(
+final Matcher isCompletionGetSuggestionsParams = new LazyMatcher(() => new MatchesJsonObject(
   "completion.getSuggestions params", {
     "file": isFilePath,
     "offset": isInt
-  });
+  }));
 
 /**
  * completion.getSuggestions result
  *
  * {
  *   "id": CompletionId
  * }
  */
-final Matcher isCompletionGetSuggestionsResult = new MatchesJsonObject(
+final Matcher isCompletionGetSuggestionsResult = new LazyMatcher(() => new MatchesJsonObject(
   "completion.getSuggestions result", {
     "id": isCompletionId
-  });
+  }));
 
 /**
  * completion.results params
  *
  * {
  *   "id": CompletionId
  *   "replacementOffset": int
  *   "replacementLength": int
  *   "results": List<CompletionSuggestion>
  *   "last": bool
  * }
  */
-final Matcher isCompletionResultsParams = new MatchesJsonObject(
+final Matcher isCompletionResultsParams = new LazyMatcher(() => new MatchesJsonObject(
   "completion.results params", {
     "id": isCompletionId,
     "replacementOffset": isInt,
     "replacementLength": isInt,
     "results": isListOf(isCompletionSuggestion),
     "last": isBool
-  });
+  }));
 
 /**
  * search.findElementReferences params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "includePotential": bool
  * }
  */
-final Matcher isSearchFindElementReferencesParams = new MatchesJsonObject(
+final Matcher isSearchFindElementReferencesParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.findElementReferences params", {
     "file": isFilePath,
     "offset": isInt,
     "includePotential": isBool
-  });
+  }));
 
 /**
  * search.findElementReferences result
  *
  * {
  *   "id": SearchId
  *   "element": Element
  * }
  */
-final Matcher isSearchFindElementReferencesResult = new MatchesJsonObject(
+final Matcher isSearchFindElementReferencesResult = new LazyMatcher(() => new MatchesJsonObject(
   "search.findElementReferences result", {
     "id": isSearchId,
     "element": isElement
-  });
+  }));
 
 /**
  * search.findMemberDeclarations params
  *
  * {
  *   "name": String
  * }
  */
-final Matcher isSearchFindMemberDeclarationsParams = new MatchesJsonObject(
+final Matcher isSearchFindMemberDeclarationsParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.findMemberDeclarations params", {
     "name": isString
-  });
+  }));
 
 /**
  * search.findMemberDeclarations result
  *
  * {
  *   "id": SearchId
  * }
  */
-final Matcher isSearchFindMemberDeclarationsResult = new MatchesJsonObject(
+final Matcher isSearchFindMemberDeclarationsResult = new LazyMatcher(() => new MatchesJsonObject(
   "search.findMemberDeclarations result", {
     "id": isSearchId
-  });
+  }));
 
 /**
  * search.findMemberReferences params
  *
  * {
  *   "name": String
  * }
  */
-final Matcher isSearchFindMemberReferencesParams = new MatchesJsonObject(
+final Matcher isSearchFindMemberReferencesParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.findMemberReferences params", {
     "name": isString
-  });
+  }));
 
 /**
  * search.findMemberReferences result
  *
  * {
  *   "id": SearchId
  * }
  */
-final Matcher isSearchFindMemberReferencesResult = new MatchesJsonObject(
+final Matcher isSearchFindMemberReferencesResult = new LazyMatcher(() => new MatchesJsonObject(
   "search.findMemberReferences result", {
     "id": isSearchId
-  });
+  }));
 
 /**
  * search.findTopLevelDeclarations params
  *
  * {
  *   "pattern": String
  * }
  */
-final Matcher isSearchFindTopLevelDeclarationsParams = new MatchesJsonObject(
+final Matcher isSearchFindTopLevelDeclarationsParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.findTopLevelDeclarations params", {
     "pattern": isString
-  });
+  }));
 
 /**
  * search.findTopLevelDeclarations result
  *
  * {
  *   "id": SearchId
  * }
  */
-final Matcher isSearchFindTopLevelDeclarationsResult = new MatchesJsonObject(
+final Matcher isSearchFindTopLevelDeclarationsResult = new LazyMatcher(() => new MatchesJsonObject(
   "search.findTopLevelDeclarations result", {
     "id": isSearchId
-  });
+  }));
 
 /**
  * search.getTypeHierarchy params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-final Matcher isSearchGetTypeHierarchyParams = new MatchesJsonObject(
+final Matcher isSearchGetTypeHierarchyParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.getTypeHierarchy params", {
     "file": isFilePath,
     "offset": isInt
-  });
+  }));
 
 /**
  * search.getTypeHierarchy result
  *
  * {
  *   "hierarchyItems": optional List<TypeHierarchyItem>
  * }
  */
-final Matcher isSearchGetTypeHierarchyResult = new MatchesJsonObject(
+final Matcher isSearchGetTypeHierarchyResult = new LazyMatcher(() => new MatchesJsonObject(
   "search.getTypeHierarchy result", null, optionalFields: {
     "hierarchyItems": isListOf(isTypeHierarchyItem)
-  });
+  }));
 
 /**
  * search.results params
  *
  * {
  *   "id": SearchId
  *   "results": List<SearchResult>
  *   "last": bool
  * }
  */
-final Matcher isSearchResultsParams = new MatchesJsonObject(
+final Matcher isSearchResultsParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.results params", {
     "id": isSearchId,
     "results": isListOf(isSearchResult),
     "last": isBool
-  });
+  }));
 
 /**
  * edit.getAssists params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
-final Matcher isEditGetAssistsParams = new MatchesJsonObject(
+final Matcher isEditGetAssistsParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getAssists params", {
     "file": isFilePath,
     "offset": isInt,
     "length": isInt
-  });
+  }));
 
 /**
  * edit.getAssists result
  *
  * {
  *   "assists": List<SourceChange>
  * }
  */
-final Matcher isEditGetAssistsResult = new MatchesJsonObject(
+final Matcher isEditGetAssistsResult = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getAssists result", {
     "assists": isListOf(isSourceChange)
-  });
+  }));
 
 /**
  * edit.getAvailableRefactorings params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
-final Matcher isEditGetAvailableRefactoringsParams = new MatchesJsonObject(
+final Matcher isEditGetAvailableRefactoringsParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getAvailableRefactorings params", {
     "file": isFilePath,
     "offset": isInt,
     "length": isInt
-  });
+  }));
 
 /**
  * edit.getAvailableRefactorings result
  *
  * {
  *   "kinds": List<RefactoringKind>
  * }
  */
-final Matcher isEditGetAvailableRefactoringsResult = new MatchesJsonObject(
+final Matcher isEditGetAvailableRefactoringsResult = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getAvailableRefactorings result", {
     "kinds": isListOf(isRefactoringKind)
-  });
+  }));
 
 /**
  * edit.getFixes params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-final Matcher isEditGetFixesParams = new MatchesJsonObject(
+final Matcher isEditGetFixesParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getFixes params", {
     "file": isFilePath,
     "offset": isInt
-  });
+  }));
 
 /**
  * edit.getFixes result
  *
  * {
  *   "fixes": List<ErrorFixes>
  * }
  */
-final Matcher isEditGetFixesResult = new MatchesJsonObject(
+final Matcher isEditGetFixesResult = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getFixes result", {
     "fixes": isListOf(isErrorFixes)
-  });
+  }));
 
 /**
  * edit.getRefactoring params
  *
  * {
  *   "kindId": RefactoringKind
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "validateOnly": bool
  *   "options": optional object
  * }
  */
-final Matcher isEditGetRefactoringParams = new MatchesJsonObject(
+final Matcher isEditGetRefactoringParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getRefactoring params", {
     "kindId": isRefactoringKind,
     "file": isFilePath,
     "offset": isInt,
     "length": isInt,
     "validateOnly": isBool
   }, optionalFields: {
     "options": isObject
-  });
+  }));
 
 /**
  * edit.getRefactoring result
  *
  * {
  *   "status": List<RefactoringProblem>
  *   "feedback": optional object
  *   "change": optional SourceChange
  * }
  */
-final Matcher isEditGetRefactoringResult = new MatchesJsonObject(
+final Matcher isEditGetRefactoringResult = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getRefactoring result", {
     "status": isListOf(isRefactoringProblem)
   }, optionalFields: {
     "feedback": isObject,
     "change": isSourceChange
-  });
+  }));
 
 /**
  * debug.createContext params
  *
  * {
  *   "contextRoot": FilePath
  * }
  */
-final Matcher isDebugCreateContextParams = new MatchesJsonObject(
+final Matcher isDebugCreateContextParams = new LazyMatcher(() => new MatchesJsonObject(
   "debug.createContext params", {
     "contextRoot": isFilePath
-  });
+  }));
 
 /**
  * debug.createContext result
  *
  * {
  *   "id": DebugContextId
  * }
  */
-final Matcher isDebugCreateContextResult = new MatchesJsonObject(
+final Matcher isDebugCreateContextResult = new LazyMatcher(() => new MatchesJsonObject(
   "debug.createContext result", {
     "id": isDebugContextId
-  });
+  }));
 
 /**
  * debug.deleteContext params
  *
  * {
  *   "id": DebugContextId
  * }
  */
-final Matcher isDebugDeleteContextParams = new MatchesJsonObject(
+final Matcher isDebugDeleteContextParams = new LazyMatcher(() => new MatchesJsonObject(
   "debug.deleteContext params", {
     "id": isDebugContextId
-  });
+  }));
 
 /**
  * debug.deleteContext result
  */
 final Matcher isDebugDeleteContextResult = isNull;
 
 /**
  * debug.mapUri params
  *
  * {
  *   "id": DebugContextId
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-final Matcher isDebugMapUriParams = new MatchesJsonObject(
+final Matcher isDebugMapUriParams = new LazyMatcher(() => new MatchesJsonObject(
   "debug.mapUri params", {
     "id": isDebugContextId
   }, optionalFields: {
     "file": isFilePath,
     "uri": isString
-  });
+  }));
 
 /**
  * debug.mapUri result
  *
  * {
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-final Matcher isDebugMapUriResult = new MatchesJsonObject(
+final Matcher isDebugMapUriResult = new LazyMatcher(() => new MatchesJsonObject(
   "debug.mapUri result", null, optionalFields: {
     "file": isFilePath,
     "uri": isString
-  });
+  }));
 
 /**
  * debug.setSubscriptions params
  *
  * {
  *   "subscriptions": List<DebugService>
  * }
  */
-final Matcher isDebugSetSubscriptionsParams = new MatchesJsonObject(
+final Matcher isDebugSetSubscriptionsParams = new LazyMatcher(() => new MatchesJsonObject(
   "debug.setSubscriptions params", {
     "subscriptions": isListOf(isDebugService)
-  });
+  }));
 
 /**
  * debug.setSubscriptions result
  */
 final Matcher isDebugSetSubscriptionsResult = isNull;
 
 /**
  * debug.launchData params
  *
  * {
  *   "executables": List<ExecutableFile>
  *   "dartToHtml": Map<FilePath, List<FilePath>>
  *   "htmlToDart": Map<FilePath, List<FilePath>>
  * }
  */
-final Matcher isDebugLaunchDataParams = new MatchesJsonObject(
+final Matcher isDebugLaunchDataParams = new LazyMatcher(() => new MatchesJsonObject(
   "debug.launchData params", {
     "executables": isListOf(isExecutableFile),
     "dartToHtml": isMapOf(isFilePath, isListOf(isFilePath)),
     "htmlToDart": isMapOf(isFilePath, isListOf(isFilePath))
-  });
+  }));
 
 /**
  * AddContentOverlay
  *
  * {
  *   "type": "add"
  *   "content": String
  * }
  */
-final Matcher isAddContentOverlay = new MatchesJsonObject(
+final Matcher isAddContentOverlay = new LazyMatcher(() => new MatchesJsonObject(
   "AddContentOverlay", {
     "type": equals("add"),
     "content": isString
-  });
+  }));
 
 /**
  * AnalysisError
  *
  * {
  *   "severity": ErrorSeverity
  *   "type": ErrorType
  *   "location": Location
  *   "message": String
  *   "correction": optional String
  * }
  */
-final Matcher isAnalysisError = new MatchesJsonObject(
+final Matcher isAnalysisError = new LazyMatcher(() => new MatchesJsonObject(
   "AnalysisError", {
     "severity": isErrorSeverity,
     "type": isErrorType,
     "location": isLocation,
     "message": isString
   }, optionalFields: {
     "correction": isString
-  });
+  }));
 
 /**
  * AnalysisOptions
  *
  * {
  *   "enableAsync": optional bool
  *   "enableDeferredLoading": optional bool
  *   "enableEnums": optional bool
  *   "generateDart2jsHints": optional bool
  *   "generateHints": optional bool
  * }
  */
-final Matcher isAnalysisOptions = new MatchesJsonObject(
+final Matcher isAnalysisOptions = new LazyMatcher(() => new MatchesJsonObject(
   "AnalysisOptions", null, optionalFields: {
     "enableAsync": isBool,
     "enableDeferredLoading": isBool,
     "enableEnums": isBool,
     "generateDart2jsHints": isBool,
     "generateHints": isBool
-  });
+  }));
 
 /**
  * AnalysisService
  *
  * enum {
  *   FOLDING
  *   HIGHLIGHTS
  *   NAVIGATION
  *   OCCURRENCES
  *   OUTLINE
@@ skipping 10 matching lines @@
 ]);
 
 /**
  * AnalysisStatus
  *
  * {
  *   "analyzing": bool
  *   "analysisTarget": optional String
  * }
  */
-final Matcher isAnalysisStatus = new MatchesJsonObject(
+final Matcher isAnalysisStatus = new LazyMatcher(() => new MatchesJsonObject(
   "AnalysisStatus", {
     "analyzing": isBool
   }, optionalFields: {
     "analysisTarget": isString
-  });
+  }));
 
 /**
  * ChangeContentOverlay
  *
  * {
  *   "type": "change"
  *   "edits": List<SourceEdit>
  * }
  */
-final Matcher isChangeContentOverlay = new MatchesJsonObject(
+final Matcher isChangeContentOverlay = new LazyMatcher(() => new MatchesJsonObject(
   "ChangeContentOverlay", {
     "type": equals("change"),
     "edits": isListOf(isSourceEdit)
-  });
+  }));
 
 /**
  * CompletionId
  *
  * String
  */
 final Matcher isCompletionId = isString;
 
 /**
  * CompletionRelevance
@@ skipping 26 matching lines @@
  *   "declaringType": optional String
  *   "returnType": optional String
  *   "parameterNames": optional List<String>
  *   "parameterTypes": optional List<String>
  *   "requiredParameterCount": optional int
  *   "positionalParameterCount": optional int
  *   "parameterName": optional String
  *   "parameterType": optional String
  * }
  */
-final Matcher isCompletionSuggestion = new MatchesJsonObject(
+final Matcher isCompletionSuggestion = new LazyMatcher(() => new MatchesJsonObject(
   "CompletionSuggestion", {
     "kind": isCompletionSuggestionKind,
     "relevance": isCompletionRelevance,
     "completion": isString,
     "selectionOffset": isInt,
     "selectionLength": isInt,
     "isDeprecated": isBool,
     "isPotential": isBool
   }, optionalFields: {
     "docSummary": isString,
     "docComplete": isString,
     "declaringType": isString,
     "returnType": isString,
     "parameterNames": isListOf(isString),
     "parameterTypes": isListOf(isString),
     "requiredParameterCount": isInt,
     "positionalParameterCount": isInt,
     "parameterName": isString,
     "parameterType": isString
-  });
+  }));
 
 /**
  * CompletionSuggestionKind
  *
  * enum {
  *   ARGUMENT_LIST
  *   CLASS
  *   CLASS_ALIAS
  *   CONSTRUCTOR
  *   FIELD
@@ skipping 58 matching lines @@
  *
  * {
  *   "kind": ElementKind
  *   "name": String
  *   "location": optional Location
  *   "flags": int
  *   "parameters": optional String
  *   "returnType": optional String
  * }
  */
-final Matcher isElement = new MatchesJsonObject(
+final Matcher isElement = new LazyMatcher(() => new MatchesJsonObject(
   "Element", {
     "kind": isElementKind,
     "name": isString,
     "flags": isInt
   }, optionalFields: {
     "location": isLocation,
     "parameters": isString,
     "returnType": isString
-  });
+  }));
 
 /**
  * ElementKind
  *
  * enum {
  *   CLASS
  *   CLASS_TYPE_ALIAS
  *   COMPILATION_UNIT
  *   CONSTRUCTOR
  *   FIELD
@@ skipping 35 matching lines @@
 
 /**
  * Error
  *
  * {
  *   "code": String
  *   "message": String
  *   "data": optional object
  * }
  */
-final Matcher isError = new MatchesJsonObject(
+final Matcher isError = new LazyMatcher(() => new MatchesJsonObject(
   "Error", {
     "code": isString,
     "message": isString
   }, optionalFields: {
     "data": isObject
-  });
+  }));
 
 /**
  * ErrorFixes
  *
  * {
  *   "error": AnalysisError
  *   "fixes": List<SourceChange>
  * }
  */
-final Matcher isErrorFixes = new MatchesJsonObject(
+final Matcher isErrorFixes = new LazyMatcher(() => new MatchesJsonObject(
   "ErrorFixes", {
     "error": isAnalysisError,
     "fixes": isListOf(isSourceChange)
-  });
+  }));
 
 /**
  * ErrorSeverity
  *
  * enum {
  *   INFO
  *   WARNING
  *   ERROR
  * }
  */
@@ skipping 25 matching lines @@
 ]);
 
 /**
  * ExecutableFile
  *
  * {
  *   "file": FilePath
  *   "offset": ExecutableKind
  * }
  */
-final Matcher isExecutableFile = new MatchesJsonObject(
+final Matcher isExecutableFile = new LazyMatcher(() => new MatchesJsonObject(
   "ExecutableFile", {
     "file": isFilePath,
     "offset": isExecutableKind
-  });
+  }));
 
 /**
  * ExecutableKind
  *
  * enum {
  *   CLIENT
  *   EITHER
  *   SERVER
  * }
  */
@@ skipping 31 matching lines @@
 
 /**
  * FoldingRegion
  *
  * {
  *   "kind": FoldingKind
  *   "offset": int
  *   "length": int
  * }
  */
-final Matcher isFoldingRegion = new MatchesJsonObject(
+final Matcher isFoldingRegion = new LazyMatcher(() => new MatchesJsonObject(
   "FoldingRegion", {
     "kind": isFoldingKind,
     "offset": isInt,
     "length": isInt
-  });
+  }));
 
 /**
  * HighlightRegion
  *
  * {
  *   "type": HighlightRegionType
  *   "offset": int
  *   "length": int
  * }
  */
-final Matcher isHighlightRegion = new MatchesJsonObject(
+final Matcher isHighlightRegion = new LazyMatcher(() => new MatchesJsonObject(
   "HighlightRegion", {
     "type": isHighlightRegionType,
     "offset": isInt,
     "length": isInt
-  });
+  }));
 
 /**
  * HighlightRegionType
  *
  * enum {
  *   ANNOTATION
  *   BUILT_IN
  *   CLASS
  *   COMMENT_BLOCK
  *   COMMENT_DOCUMENTATION
@@ skipping 76 matching lines @@
  *   "containingLibraryPath": optional String
  *   "containingLibraryName": optional String
  *   "dartdoc": optional String
  *   "elementDescription": optional String
  *   "elementKind": optional String
  *   "parameter": optional String
  *   "propagatedType": optional String
  *   "staticType": optional String
  * }
  */
-final Matcher isHoverInformation = new MatchesJsonObject(
+final Matcher isHoverInformation = new LazyMatcher(() => new MatchesJsonObject(
   "HoverInformation", {
     "offset": isInt,
     "length": isInt
   }, optionalFields: {
     "containingLibraryPath": isString,
     "containingLibraryName": isString,
     "dartdoc": isString,
     "elementDescription": isString,
     "elementKind": isString,
     "parameter": isString,
     "propagatedType": isString,
     "staticType": isString
-  });
+  }));
 
 /**
  * LinkedEditGroup
  *
  * {
  *   "positions": List<Position>
  *   "length": int
  *   "suggestions": List<LinkedEditSuggestion>
  * }
  */
-final Matcher isLinkedEditGroup = new MatchesJsonObject(
+final Matcher isLinkedEditGroup = new LazyMatcher(() => new MatchesJsonObject(
   "LinkedEditGroup", {
     "positions": isListOf(isPosition),
     "length": isInt,
     "suggestions": isListOf(isLinkedEditSuggestion)
-  });
+  }));
 
 /**
  * LinkedEditSuggestion
  *
  * {
  *   "value": String
  *   "kind": LinkedEditSuggestionKind
  * }
  */
-final Matcher isLinkedEditSuggestion = new MatchesJsonObject(
+final Matcher isLinkedEditSuggestion = new LazyMatcher(() => new MatchesJsonObject(
   "LinkedEditSuggestion", {
     "value": isString,
     "kind": isLinkedEditSuggestionKind
-  });
+  }));
 
 /**
  * LinkedEditSuggestionKind
  *
  * enum {
  *   METHOD
  *   PARAMETER
  *   TYPE
  *   VARIABLE
  * }
  */
 final Matcher isLinkedEditSuggestionKind = new MatchesEnum("LinkedEditSuggestionKind", [
   "METHOD",
   "PARAMETER",
   "TYPE",
   "VARIABLE"
 ]);
 
 /**
  * Location
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "startLine": int
  *   "startColumn": int
  * }
  */
-final Matcher isLocation = new MatchesJsonObject(
+final Matcher isLocation = new LazyMatcher(() => new MatchesJsonObject(
   "Location", {
     "file": isFilePath,
     "offset": isInt,
     "length": isInt,
     "startLine": isInt,
     "startColumn": isInt
-  });
+  }));
 
 /**
  * NavigationRegion
  *
  * {
  *   "offset": int
  *   "length": int
  *   "targets": List<Element>
  * }
  */
-final Matcher isNavigationRegion = new MatchesJsonObject(
+final Matcher isNavigationRegion = new LazyMatcher(() => new MatchesJsonObject(
   "NavigationRegion", {
     "offset": isInt,
     "length": isInt,
     "targets": isListOf(isElement)
-  });
+  }));
 
 /**
  * Occurrences
  *
  * {
  *   "element": Element
  *   "offsets": List<int>
  *   "length": int
  * }
  */
-final Matcher isOccurrences = new MatchesJsonObject(
+final Matcher isOccurrences = new LazyMatcher(() => new MatchesJsonObject(
   "Occurrences", {
     "element": isElement,
     "offsets": isListOf(isInt),
     "length": isInt
-  });
+  }));
 
 /**
  * Outline
  *
  * {
  *   "element": Element
  *   "offset": int
  *   "length": int
  *   "children": optional List<Outline>
  * }
  */
-final Matcher isOutline = new MatchesJsonObject(
+final Matcher isOutline = new LazyMatcher(() => new MatchesJsonObject(
   "Outline", {
     "element": isElement,
     "offset": isInt,
     "length": isInt
   }, optionalFields: {
     "children": isListOf(isOutline)
-  });
+  }));
 
 /**
  * Override
  *
  * {
  *   "offset": int
  *   "length": int
  *   "superclassMember": optional OverriddenMember
  *   "interfaceMembers": optional List<OverriddenMember>
  * }
  */
-final Matcher isOverride = new MatchesJsonObject(
+final Matcher isOverride = new LazyMatcher(() => new MatchesJsonObject(
   "Override", {
     "offset": isInt,
     "length": isInt
   }, optionalFields: {
     "superclassMember": isOverriddenMember,
     "interfaceMembers": isListOf(isOverriddenMember)
-  });
+  }));
 
 /**
  * OverriddenMember
  *
  * {
  *   "element": Element
  *   "className": String
  * }
  */
-final Matcher isOverriddenMember = new MatchesJsonObject(
+final Matcher isOverriddenMember = new LazyMatcher(() => new MatchesJsonObject(
   "OverriddenMember", {
     "element": isElement,
     "className": isString
-  });
+  }));
 
 /**
  * Position
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-final Matcher isPosition = new MatchesJsonObject(
+final Matcher isPosition = new LazyMatcher(() => new MatchesJsonObject(
   "Position", {
     "file": isFilePath,
     "offset": isInt
-  });
+  }));
 
 /**
  * RefactoringKind
  *
  * enum {
  *   CONVERT_GETTER_TO_METHOD
  *   CONVERT_METHOD_TO_GETTER
  *   EXTRACT_LOCAL_VARIABLE
  *   EXTRACT_METHOD
  *   INLINE_LOCAL_VARIABLE
@@ skipping 15 matching lines @@
  * RefactoringMethodParameter
  *
  * {
  *   "id": optional String
  *   "kind": RefactoringMethodParameterKind
  *   "type": String
  *   "name": String
  *   "parameters": optional String
  * }
  */
-final Matcher isRefactoringMethodParameter = new MatchesJsonObject(
+final Matcher isRefactoringMethodParameter = new LazyMatcher(() => new MatchesJsonObject(
   "RefactoringMethodParameter", {
     "kind": isRefactoringMethodParameterKind,
     "type": isString,
     "name": isString
   }, optionalFields: {
     "id": isString,
     "parameters": isString
-  });
+  }));
 
 /**
  * RefactoringMethodParameterKind
  *
  * enum {
  *   REQUIRED
  *   POSITIONAL
  *   NAMED
  * }
  */
 final Matcher isRefactoringMethodParameterKind = new MatchesEnum("RefactoringMethodParameterKind", [
   "REQUIRED",
   "POSITIONAL",
   "NAMED"
 ]);
 
 /**
  * RefactoringProblem
  *
  * {
  *   "severity": RefactoringProblemSeverity
  *   "message": String
  *   "location": Location
  * }
  */
-final Matcher isRefactoringProblem = new MatchesJsonObject(
+final Matcher isRefactoringProblem = new LazyMatcher(() => new MatchesJsonObject(
   "RefactoringProblem", {
     "severity": isRefactoringProblemSeverity,
     "message": isString,
     "location": isLocation
-  });
+  }));
 
 /**
  * RefactoringProblemSeverity
  *
  * enum {
  *   INFO
  *   WARNING
  *   ERROR
  *   FATAL
  * }
  */
 final Matcher isRefactoringProblemSeverity = new MatchesEnum("RefactoringProblemSeverity", [
   "INFO",
   "WARNING",
   "ERROR",
   "FATAL"
 ]);
 
 /**
  * RemoveContentOverlay
  *
  * {
  *   "type": "remove"
  * }
  */
-final Matcher isRemoveContentOverlay = new MatchesJsonObject(
+final Matcher isRemoveContentOverlay = new LazyMatcher(() => new MatchesJsonObject(
   "RemoveContentOverlay", {
     "type": equals("remove")
-  });
+  }));
 
 /**
  * SearchId
  *
  * String
  */
 final Matcher isSearchId = isString;
 
 /**
  * SearchResult
  *
  * {
  *   "location": Location
  *   "kind": SearchResultKind
  *   "isPotential": bool
  *   "path": List<Element>
  * }
  */
-final Matcher isSearchResult = new MatchesJsonObject(
+final Matcher isSearchResult = new LazyMatcher(() => new MatchesJsonObject(
   "SearchResult", {
     "location": isLocation,
     "kind": isSearchResultKind,
     "isPotential": isBool,
     "path": isListOf(isElement)
-  });
+  }));
 
 /**
  * SearchResultKind
  *
  * enum {
  *   DECLARATION
  *   INVOCATION
  *   READ
  *   READ_WRITE
  *   REFERENCE
@@ skipping 23 matching lines @@
 /**
  * SourceChange
  *
  * {
  *   "message": String
  *   "edits": List<SourceFileEdit>
  *   "linkedEditGroups": List<LinkedEditGroup>
  *   "selection": optional Position
  * }
  */
-final Matcher isSourceChange = new MatchesJsonObject(
+final Matcher isSourceChange = new LazyMatcher(() => new MatchesJsonObject(
   "SourceChange", {
     "message": isString,
     "edits": isListOf(isSourceFileEdit),
     "linkedEditGroups": isListOf(isLinkedEditGroup)
   }, optionalFields: {
     "selection": isPosition
-  });
+  }));
 
 /**
  * SourceEdit
  *
  * {
  *   "offset": int
  *   "length": int
  *   "replacement": String
  * }
  */
-final Matcher isSourceEdit = new MatchesJsonObject(
+final Matcher isSourceEdit = new LazyMatcher(() => new MatchesJsonObject(
   "SourceEdit", {
     "offset": isInt,
     "length": isInt,
     "replacement": isString
-  });
+  }));
 
 /**
  * SourceFileEdit
  *
  * {
  *   "file": FilePath
  *   "edits": List<SourceEdit>
  * }
  */
-final Matcher isSourceFileEdit = new MatchesJsonObject(
+final Matcher isSourceFileEdit = new LazyMatcher(() => new MatchesJsonObject(
   "SourceFileEdit", {
     "file": isFilePath,
     "edits": isListOf(isSourceEdit)
-  });
+  }));
 
 /**
  * TypeHierarchyItem
  *
  * {
  *   "classElement": Element
  *   "displayName": optional String
  *   "memberElement": optional Element
  *   "superclass": optional int
  *   "interfaces": List<int>
  *   "mixins": List<int>
  *   "subclasses": List<int>
  * }
  */
-final Matcher isTypeHierarchyItem = new MatchesJsonObject(
+final Matcher isTypeHierarchyItem = new LazyMatcher(() => new MatchesJsonObject(
   "TypeHierarchyItem", {
     "classElement": isElement,
     "interfaces": isListOf(isInt),
     "mixins": isListOf(isInt),
     "subclasses": isListOf(isInt)
   }, optionalFields: {
     "displayName": isString,
     "memberElement": isElement,
     "superclass": isInt
-  });
+  }));
 
 /**
  * convertGetterToMethod feedback
  */
 final Matcher isConvertGetterToMethodFeedback = isNull;
 
 /**
  * convertGetterToMethod options
  */
 final Matcher isConvertGetterToMethodOptions = isNull;
@@ skipping 10 matching lines @@
 
 /**
  * extractLocalVariable feedback
  *
  * {
  *   "names": List<String>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-final Matcher isExtractLocalVariableFeedback = new MatchesJsonObject(
+final Matcher isExtractLocalVariableFeedback = new LazyMatcher(() => new MatchesJsonObject(
   "extractLocalVariable feedback", {
     "names": isListOf(isString),
     "offsets": isListOf(isInt),
     "lengths": isListOf(isInt)
-  });
+  }));
 
 /**
  * extractLocalVariable options
  *
  * {
  *   "name": String
  *   "extractAll": bool
  * }
  */
-final Matcher isExtractLocalVariableOptions = new MatchesJsonObject(
+final Matcher isExtractLocalVariableOptions = new LazyMatcher(() => new MatchesJsonObject(
   "extractLocalVariable options", {
     "name": isString,
     "extractAll": isBool
-  });
+  }));
 
 /**
  * extractMethod feedback
  *
  * {
  *   "offset": int
  *   "length": int
  *   "returnType": String
  *   "names": List<String>
  *   "canCreateGetter": bool
  *   "parameters": List<RefactoringMethodParameter>
  *   "occurrences": int
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-final Matcher isExtractMethodFeedback = new MatchesJsonObject(
+final Matcher isExtractMethodFeedback = new LazyMatcher(() => new MatchesJsonObject(
   "extractMethod feedback", {
     "offset": isInt,
     "length": isInt,
     "returnType": isString,
     "names": isListOf(isString),
     "canCreateGetter": isBool,
     "parameters": isListOf(isRefactoringMethodParameter),
     "occurrences": isInt,
     "offsets": isListOf(isInt),
     "lengths": isListOf(isInt)
-  });
+  }));
 
 /**
  * extractMethod options
  *
  * {
  *   "returnType": String
  *   "createGetter": bool
  *   "name": String
  *   "parameters": List<RefactoringMethodParameter>
  *   "extractAll": bool
  * }
  */
-final Matcher isExtractMethodOptions = new MatchesJsonObject(
+final Matcher isExtractMethodOptions = new LazyMatcher(() => new MatchesJsonObject(
   "extractMethod options", {
     "returnType": isString,
     "createGetter": isBool,
     "name": isString,
     "parameters": isListOf(isRefactoringMethodParameter),
     "extractAll": isBool
-  });
+  }));
 
 /**
  * inlineLocalVariable feedback
  */
 final Matcher isInlineLocalVariableFeedback = isNull;
 
 /**
  * inlineLocalVariable options
  */
 final Matcher isInlineLocalVariableOptions = isNull;
 
 /**
  * inlineMethod feedback
  */
 final Matcher isInlineMethodFeedback = isNull;
 
 /**
  * inlineMethod options
  *
  * {
  *   "deleteSource": bool
  *   "inlineAll": bool
  * }
  */
-final Matcher isInlineMethodOptions = new MatchesJsonObject(
+final Matcher isInlineMethodOptions = new LazyMatcher(() => new MatchesJsonObject(
   "inlineMethod options", {
     "deleteSource": isBool,
     "inlineAll": isBool
-  });
+  }));
 
 /**
  * rename feedback
  *
  * {
  *   "offset": int
  *   "length": int
  * }
  */
-final Matcher isRenameFeedback = new MatchesJsonObject(
+final Matcher isRenameFeedback = new LazyMatcher(() => new MatchesJsonObject(
   "rename feedback", {
     "offset": isInt,
     "length": isInt
-  });
+  }));
 
 /**
  * rename options
  *
  * {
  *   "newName": String
  * }
  */
-final Matcher isRenameOptions = new MatchesJsonObject(
+final Matcher isRenameOptions = new LazyMatcher(() => new MatchesJsonObject(
   "rename options", {
     "newName": isString
-  });
+  }));