Change analysis server protocol to omit empty lists when optional.

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 29 matching lines @@
 
 /**
  * server.shutdown result
  */
 final Matcher isServerShutdownResult = isNull;
 
 /**
  * server.setSubscriptions params
  *
  * {
- *   "subscriptions": List<ServerService>
+ *   "subscriptions": optional List<ServerService>
  * }
  */
 final Matcher isServerSetSubscriptionsParams = new LazyMatcher(() => new MatchesJsonObject(
-  "server.setSubscriptions params", {
+  "server.setSubscriptions params", null, optionalFields: {
     "subscriptions": isListOf(isServerService)
   }));
 
 /**
  * server.setSubscriptions result
  */
 final Matcher isServerSetSubscriptionsResult = isNull;
 
 /**
  * server.connected params
@@ skipping 37 matching lines @@
  */
 final Matcher isAnalysisGetErrorsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.getErrors params", {
     "file": isFilePath
   }));
 
 /**
  * analysis.getErrors result
  *
  * {
- *   "errors": List<AnalysisError>
+ *   "errors": optional List<AnalysisError>
  * }
  */
 final Matcher isAnalysisGetErrorsResult = new LazyMatcher(() => new MatchesJsonObject(
-  "analysis.getErrors result", {
+  "analysis.getErrors result", null, optionalFields: {
     "errors": isListOf(isAnalysisError)
   }));
 
 /**
  * analysis.getHover params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
 final Matcher isAnalysisGetHoverParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.getHover params", {
     "file": isFilePath,
     "offset": isInt
   }));
 
 /**
  * analysis.getHover result
  *
  * {
- *   "hovers": List<HoverInformation>
+ *   "hovers": optional List<HoverInformation>
  * }
  */
 final Matcher isAnalysisGetHoverResult = new LazyMatcher(() => new MatchesJsonObject(
-  "analysis.getHover result", {
+  "analysis.getHover result", null, optionalFields: {
     "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>
+ *   "included": optional List<FilePath>
+ *   "excluded": optional List<FilePath>
  * }
  */
 final Matcher isAnalysisSetAnalysisRootsParams = new LazyMatcher(() => new MatchesJsonObject(
-  "analysis.setAnalysisRoots params", {
+  "analysis.setAnalysisRoots params", null, optionalFields: {
     "included": isListOf(isFilePath),
     "excluded": isListOf(isFilePath)
   }));
 
 /**
  * analysis.setAnalysisRoots result
  */
 final Matcher isAnalysisSetAnalysisRootsResult = isNull;
 
 /**
  * analysis.setPriorityFiles params
  *
  * {
- *   "files": List<FilePath>
+ *   "files": optional List<FilePath>
  * }
  */
 final Matcher isAnalysisSetPriorityFilesParams = new LazyMatcher(() => new MatchesJsonObject(
-  "analysis.setPriorityFiles params", {
+  "analysis.setPriorityFiles params", null, optionalFields: {
     "files": isListOf(isFilePath)
   }));
 
 /**
  * analysis.setPriorityFiles result
  */
 final Matcher isAnalysisSetPriorityFilesResult = isNull;
 
 /**
  * analysis.setSubscriptions params
@@ skipping 44 matching lines @@
 /**
  * analysis.updateOptions result
  */
 final Matcher isAnalysisUpdateOptionsResult = isNull;
 
 /**
  * analysis.errors params
  *
  * {
  *   "file": FilePath
- *   "errors": List<AnalysisError>
+ *   "errors": optional List<AnalysisError>
  * }
  */
 final Matcher isAnalysisErrorsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.errors params", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "errors": isListOf(isAnalysisError)
   }));
 
 /**
  * analysis.flushResults params
  *
  * {
- *   "files": List<FilePath>
+ *   "files": optional List<FilePath>
  * }
  */
 final Matcher isAnalysisFlushResultsParams = new LazyMatcher(() => new MatchesJsonObject(
-  "analysis.flushResults params", {
+  "analysis.flushResults params", null, optionalFields: {
     "files": isListOf(isFilePath)
   }));
 
 /**
  * analysis.folding params
  *
  * {
  *   "file": FilePath
- *   "regions": List<FoldingRegion>
+ *   "regions": optional List<FoldingRegion>
  * }
  */
 final Matcher isAnalysisFoldingParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.folding params", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "regions": isListOf(isFoldingRegion)
   }));
 
 /**
  * analysis.highlights params
  *
  * {
  *   "file": FilePath
- *   "regions": List<HighlightRegion>
+ *   "regions": optional List<HighlightRegion>
  * }
  */
 final Matcher isAnalysisHighlightsParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.highlights params", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "regions": isListOf(isHighlightRegion)
   }));
 
 /**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
- *   "regions": List<NavigationRegion>
+ *   "regions": optional List<NavigationRegion>
  * }
  */
 final Matcher isAnalysisNavigationParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.navigation params", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "regions": isListOf(isNavigationRegion)
   }));
 
 /**
  * analysis.occurrences params
  *
  * {
  *   "file": FilePath
- *   "occurrences": List<Occurrences>
+ *   "occurrences": optional List<Occurrences>
  * }
  */
 final Matcher isAnalysisOccurrencesParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.occurrences params", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "occurrences": isListOf(isOccurrences)
   }));
 
 /**
  * analysis.outline params
  *
  * {
  *   "file": FilePath
  *   "outline": Outline
  * }
  */
 final Matcher isAnalysisOutlineParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.outline params", {
     "file": isFilePath,
     "outline": isOutline
   }));
 
 /**
  * analysis.overrides params
  *
  * {
  *   "file": FilePath
- *   "overrides": List<Override>
+ *   "overrides": optional List<Override>
  * }
  */
 final Matcher isAnalysisOverridesParams = new LazyMatcher(() => new MatchesJsonObject(
   "analysis.overrides params", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "overrides": isListOf(isOverride)
   }));
 
 /**
  * completion.getSuggestions params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
@@ skipping 16 matching lines @@
     "id": isCompletionId
   }));
 
 /**
  * completion.results params
  *
  * {
  *   "id": CompletionId
  *   "replacementOffset": int
  *   "replacementLength": int
- *   "results": List<CompletionSuggestion>
+ *   "results": optional List<CompletionSuggestion>
  *   "last": bool
  * }
  */
 final Matcher isCompletionResultsParams = new LazyMatcher(() => new MatchesJsonObject(
   "completion.results params", {
     "id": isCompletionId,
     "replacementOffset": isInt,
     "replacementLength": isInt,
-    "results": isListOf(isCompletionSuggestion),
     "last": isBool
+  }, optionalFields: {
+    "results": isListOf(isCompletionSuggestion)
   }));
 
 /**
  * search.findElementReferences params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "includePotential": bool
  * }
@@ skipping 116 matching lines @@
 final Matcher isSearchGetTypeHierarchyResult = new LazyMatcher(() => new MatchesJsonObject(
   "search.getTypeHierarchy result", null, optionalFields: {
     "hierarchyItems": isListOf(isTypeHierarchyItem)
   }));
 
 /**
  * search.results params
  *
  * {
  *   "id": SearchId
- *   "results": List<SearchResult>
+ *   "results": optional List<SearchResult>
  *   "last": bool
  * }
  */
 final Matcher isSearchResultsParams = new LazyMatcher(() => new MatchesJsonObject(
   "search.results params", {
     "id": isSearchId,
-    "results": isListOf(isSearchResult),
     "last": isBool
+  }, optionalFields: {
+    "results": isListOf(isSearchResult)
   }));
 
 /**
  * edit.getAssists params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
 final Matcher isEditGetAssistsParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getAssists params", {
     "file": isFilePath,
     "offset": isInt,
     "length": isInt
   }));
 
 /**
  * edit.getAssists result
  *
  * {
- *   "assists": List<SourceChange>
+ *   "assists": optional List<SourceChange>
  * }
  */
 final Matcher isEditGetAssistsResult = new LazyMatcher(() => new MatchesJsonObject(
-  "edit.getAssists result", {
+  "edit.getAssists result", null, optionalFields: {
     "assists": isListOf(isSourceChange)
   }));
 
 /**
  * edit.getAvailableRefactorings params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
 final Matcher isEditGetAvailableRefactoringsParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getAvailableRefactorings params", {
     "file": isFilePath,
     "offset": isInt,
     "length": isInt
   }));
 
 /**
  * edit.getAvailableRefactorings result
  *
  * {
- *   "kinds": List<RefactoringKind>
+ *   "kinds": optional List<RefactoringKind>
  * }
  */
 final Matcher isEditGetAvailableRefactoringsResult = new LazyMatcher(() => new MatchesJsonObject(
-  "edit.getAvailableRefactorings result", {
+  "edit.getAvailableRefactorings result", null, optionalFields: {
     "kinds": isListOf(isRefactoringKind)
   }));
 
 /**
  * edit.getFixes params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
 final Matcher isEditGetFixesParams = new LazyMatcher(() => new MatchesJsonObject(
   "edit.getFixes params", {
     "file": isFilePath,
     "offset": isInt
   }));
 
 /**
  * edit.getFixes result
  *
  * {
- *   "fixes": List<ErrorFixes>
+ *   "fixes": optional List<ErrorFixes>
  * }
  */
 final Matcher isEditGetFixesResult = new LazyMatcher(() => new MatchesJsonObject(
-  "edit.getFixes result", {
+  "edit.getFixes result", null, optionalFields: {
     "fixes": isListOf(isErrorFixes)
   }));
 
 /**
  * edit.getRefactoring params
  *
  * {
  *   "kind": RefactoringKind
  *   "file": FilePath
  *   "offset": int
@@ skipping 10 matching lines @@
     "length": isInt,
     "validateOnly": isBool
   }, optionalFields: {
     "options": isObject
   }));
 
 /**
  * edit.getRefactoring result
  *
  * {
- *   "status": List<RefactoringProblem>
+ *   "status": optional List<RefactoringProblem>
  *   "feedback": optional object
  *   "change": optional SourceChange
  *   "potentialEdits": optional List<String>
  * }
  */
 final Matcher isEditGetRefactoringResult = new LazyMatcher(() => new MatchesJsonObject(
-  "edit.getRefactoring result", {
-    "status": isListOf(isRefactoringProblem)
-  }, optionalFields: {
+  "edit.getRefactoring result", null, optionalFields: {
+    "status": isListOf(isRefactoringProblem),
     "feedback": isObject,
     "change": isSourceChange,
     "potentialEdits": isListOf(isString)
   }));
 
 /**
  * debug.createContext params
  *
  * {
  *   "contextRoot": FilePath
@@ skipping 61 matching lines @@
 final Matcher isDebugMapUriResult = new LazyMatcher(() => new MatchesJsonObject(
   "debug.mapUri result", null, optionalFields: {
     "file": isFilePath,
     "uri": isString
   }));
 
 /**
  * debug.setSubscriptions params
  *
  * {
- *   "subscriptions": List<DebugService>
+ *   "subscriptions": optional List<DebugService>
  * }
  */
 final Matcher isDebugSetSubscriptionsParams = new LazyMatcher(() => new MatchesJsonObject(
-  "debug.setSubscriptions params", {
+  "debug.setSubscriptions params", null, optionalFields: {
     "subscriptions": isListOf(isDebugService)
   }));
 
 /**
  * debug.setSubscriptions result
  */
 final Matcher isDebugSetSubscriptionsResult = isNull;
 
 /**
  * debug.launchData params
  *
  * {
- *   "executables": List<ExecutableFile>
+ *   "executables": optional List<ExecutableFile>
  *   "dartToHtml": Map<FilePath, List<FilePath>>
  *   "htmlToDart": Map<FilePath, List<FilePath>>
  * }
  */
 final Matcher isDebugLaunchDataParams = new LazyMatcher(() => new MatchesJsonObject(
   "debug.launchData params", {
-    "executables": isListOf(isExecutableFile),
     "dartToHtml": isMapOf(isFilePath, isListOf(isFilePath)),
     "htmlToDart": isMapOf(isFilePath, isListOf(isFilePath))
+  }, optionalFields: {
+    "executables": isListOf(isExecutableFile)
   }));
 
 /**
  * AddContentOverlay
  *
  * {
  *   "type": "add"
  *   "content": String
  * }
  */
@@ skipping 78 matching lines @@
     "analyzing": isBool
   }, optionalFields: {
     "analysisTarget": isString
   }));
 
 /**
  * ChangeContentOverlay
  *
  * {
  *   "type": "change"
- *   "edits": List<SourceEdit>
+ *   "edits": optional List<SourceEdit>
  * }
  */
 final Matcher isChangeContentOverlay = new LazyMatcher(() => new MatchesJsonObject(
   "ChangeContentOverlay", {
-    "type": equals("change"),
+    "type": equals("change")
+  }, optionalFields: {
     "edits": isListOf(isSourceEdit)
   }));
 
 /**
  * CompletionId
  *
  * String
  */
 final Matcher isCompletionId = isString;
 
@@ skipping 207 matching lines @@
     "message": isString
   }, optionalFields: {
     "data": isObject
   }));
 
 /**
  * ErrorFixes
  *
  * {
  *   "error": AnalysisError
- *   "fixes": List<SourceChange>
+ *   "fixes": optional List<SourceChange>
  * }
  */
 final Matcher isErrorFixes = new LazyMatcher(() => new MatchesJsonObject(
   "ErrorFixes", {
-    "error": isAnalysisError,
+    "error": isAnalysisError
+  }, optionalFields: {
     "fixes": isListOf(isSourceChange)
   }));
 
 /**
  * ErrorSeverity
  *
  * enum {
  *   INFO
  *   WARNING
  *   ERROR
@@ skipping 220 matching lines @@
     "elementKind": isString,
     "parameter": isString,
     "propagatedType": isString,
     "staticType": isString
   }));
 
 /**
  * LinkedEditGroup
  *
  * {
- *   "positions": List<Position>
+ *   "positions": optional List<Position>
  *   "length": int
- *   "suggestions": List<LinkedEditSuggestion>
+ *   "suggestions": optional List<LinkedEditSuggestion>
  * }
  */
 final Matcher isLinkedEditGroup = new LazyMatcher(() => new MatchesJsonObject(
   "LinkedEditGroup", {
+    "length": isInt
+  }, optionalFields: {
     "positions": isListOf(isPosition),
-    "length": isInt,
     "suggestions": isListOf(isLinkedEditSuggestion)
   }));
 
 /**
  * LinkedEditSuggestion
  *
  * {
  *   "value": String
  *   "kind": LinkedEditSuggestionKind
  * }
@@ skipping 40 matching lines @@
     "startLine": isInt,
     "startColumn": isInt
   }));
 
 /**
  * NavigationRegion
  *
  * {
  *   "offset": int
  *   "length": int
- *   "targets": List<Element>
+ *   "targets": optional List<Element>
  * }
  */
 final Matcher isNavigationRegion = new LazyMatcher(() => new MatchesJsonObject(
   "NavigationRegion", {
     "offset": isInt,
-    "length": isInt,
+    "length": isInt
+  }, optionalFields: {
     "targets": isListOf(isElement)
   }));
 
 /**
  * Occurrences
  *
  * {
  *   "element": Element
- *   "offsets": List<int>
+ *   "offsets": optional List<int>
  *   "length": int
  * }
  */
 final Matcher isOccurrences = new LazyMatcher(() => new MatchesJsonObject(
   "Occurrences", {
     "element": isElement,
-    "offsets": isListOf(isInt),
     "length": isInt
+  }, optionalFields: {
+    "offsets": isListOf(isInt)
   }));
 
 /**
  * Outline
  *
  * {
  *   "element": Element
  *   "offset": int
  *   "length": int
  *   "children": optional List<Outline>
@@ skipping 167 matching lines @@
  */
 final Matcher isSearchId = isString;
 
 /**
  * SearchResult
  *
  * {
  *   "location": Location
  *   "kind": SearchResultKind
  *   "isPotential": bool
- *   "path": List<Element>
+ *   "path": optional List<Element>
  * }
  */
 final Matcher isSearchResult = new LazyMatcher(() => new MatchesJsonObject(
   "SearchResult", {
     "location": isLocation,
     "kind": isSearchResultKind,
-    "isPotential": isBool,
+    "isPotential": isBool
+  }, optionalFields: {
     "path": isListOf(isElement)
   }));
 
 /**
  * SearchResultKind
  *
  * enum {
  *   DECLARATION
  *   INVOCATION
  *   READ
@@ skipping 22 matching lines @@
  */
 final Matcher isServerService = new MatchesEnum("ServerService", [
   "STATUS"
 ]);
 
 /**
  * SourceChange
  *
  * {
  *   "message": String
- *   "edits": List<SourceFileEdit>
- *   "linkedEditGroups": List<LinkedEditGroup>
+ *   "edits": optional List<SourceFileEdit>
+ *   "linkedEditGroups": optional List<LinkedEditGroup>
  *   "selection": optional Position
  * }
  */
 final Matcher isSourceChange = new LazyMatcher(() => new MatchesJsonObject(
   "SourceChange", {
-    "message": isString,
+    "message": isString
+  }, optionalFields: {
     "edits": isListOf(isSourceFileEdit),
-    "linkedEditGroups": isListOf(isLinkedEditGroup)
-  }, optionalFields: {
+    "linkedEditGroups": isListOf(isLinkedEditGroup),
     "selection": isPosition
   }));
 
 /**
  * SourceEdit
  *
  * {
  *   "offset": int
  *   "length": int
  *   "replacement": String
  *   "id": optional String
  * }
  */
 final Matcher isSourceEdit = new LazyMatcher(() => new MatchesJsonObject(
   "SourceEdit", {
     "offset": isInt,
     "length": isInt,
     "replacement": isString
   }, optionalFields: {
     "id": isString
   }));
 
 /**
  * SourceFileEdit
  *
  * {
  *   "file": FilePath
- *   "edits": List<SourceEdit>
+ *   "edits": optional List<SourceEdit>
  * }
  */
 final Matcher isSourceFileEdit = new LazyMatcher(() => new MatchesJsonObject(
   "SourceFileEdit", {
-    "file": isFilePath,
+    "file": isFilePath
+  }, optionalFields: {
     "edits": isListOf(isSourceEdit)
   }));
 
 /**
  * TypeHierarchyItem
  *
  * {
  *   "classElement": Element
  *   "displayName": optional String
  *   "memberElement": optional Element
  *   "superclass": optional int
- *   "interfaces": List<int>
- *   "mixins": List<int>
- *   "subclasses": List<int>
+ *   "interfaces": optional List<int>
+ *   "mixins": optional List<int>
+ *   "subclasses": optional List<int>
  * }
  */
 final Matcher isTypeHierarchyItem = new LazyMatcher(() => new MatchesJsonObject(
   "TypeHierarchyItem", {
-    "classElement": isElement,
+    "classElement": isElement
+  }, optionalFields: {
+    "displayName": isString,
+    "memberElement": isElement,
+    "superclass": isInt,
     "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;
 
 /**
  * convertMethodToGetter feedback
  */
 final Matcher isConvertMethodToGetterFeedback = isNull;
 
 /**
  * convertMethodToGetter options
  */
 final Matcher isConvertMethodToGetterOptions = isNull;
 
 /**
  * extractLocalVariable feedback
  *
  * {
- *   "names": List<String>
- *   "offsets": List<int>
- *   "lengths": List<int>
+ *   "names": optional List<String>
+ *   "offsets": optional List<int>
+ *   "lengths": optional List<int>
  * }
  */
 final Matcher isExtractLocalVariableFeedback = new LazyMatcher(() => new MatchesJsonObject(
-  "extractLocalVariable feedback", {
+  "extractLocalVariable feedback", null, optionalFields: {
     "names": isListOf(isString),
     "offsets": isListOf(isInt),
     "lengths": isListOf(isInt)
   }));
 
 /**
  * extractLocalVariable options
  *
  * {
  *   "name": String
  *   "extractAll": bool
  * }
  */
 final Matcher isExtractLocalVariableOptions = new LazyMatcher(() => new MatchesJsonObject(
   "extractLocalVariable options", {
     "name": isString,
     "extractAll": isBool
   }));
 
 /**
  * extractMethod feedback
  *
  * {
  *   "offset": int
  *   "length": int
  *   "returnType": String
- *   "names": List<String>
+ *   "names": optional List<String>
  *   "canCreateGetter": bool
- *   "parameters": List<RefactoringMethodParameter>
+ *   "parameters": optional List<RefactoringMethodParameter>
  *   "occurrences": int
- *   "offsets": List<int>
- *   "lengths": List<int>
+ *   "offsets": optional List<int>
+ *   "lengths": optional List<int>
  * }
  */
 final Matcher isExtractMethodFeedback = new LazyMatcher(() => new MatchesJsonObject(
   "extractMethod feedback", {
     "offset": isInt,
     "length": isInt,
     "returnType": isString,
+    "canCreateGetter": isBool,
+    "occurrences": isInt
+  }, optionalFields: {
     "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>
+ *   "parameters": optional List<RefactoringMethodParameter>
  *   "extractAll": bool
  * }
  */
 final Matcher isExtractMethodOptions = new LazyMatcher(() => new MatchesJsonObject(
   "extractMethod options", {
     "returnType": isString,
     "createGetter": isBool,
     "name": isString,
-    "parameters": isListOf(isRefactoringMethodParameter),
     "extractAll": isBool
+  }, optionalFields: {
+    "parameters": isListOf(isRefactoringMethodParameter)
   }));
 
 /**
  * inlineLocalVariable feedback
  */
 final Matcher isInlineLocalVariableFeedback = isNull;
 
 /**
  * inlineLocalVariable options
  */
@@ skipping 37 matching lines @@
  *
  * {
  *   "newName": String
  * }
  */
 final Matcher isRenameOptions = new LazyMatcher(() => new MatchesJsonObject(
   "rename options", {
     "newName": isString
   }));