Fix lints: unnecessary_brace_in_string_interp

pkg/analysis_server/lib/src/services/refactoring/extract_method.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library services.src.refactoring.extract_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
@@ skipping 201 matching lines @@
 
   @override
   RefactoringStatus checkName() {
     return validateMethodName(name);
   }
 
   @override
   Future<SourceChange> createChange() async {
     SourceChange change = new SourceChange(refactoringName);
     // replace occurrences with method invocation
-    for (_Occurrence occurence in _occurrences) {
-      SourceRange range = occurence.range;
+    for (_Occurrence occurrence in _occurrences) {
+      SourceRange range = occurrence.range;
       // may be replacement of duplicates disabled
-      if (!extractAll && !occurence.isSelection) {
+      if (!extractAll && !occurrence.isSelection) {
         continue;
       }
       // prepare invocation source
       String invocationSource;
       if (_selectionFunctionExpression != null) {
         invocationSource = name;
       } else {
         StringBuffer sb = new StringBuffer();
         // may be returns value
         if (_selectionStatements != null && variableType != null) {
           // single variable assignment / return statement
           if (_returnVariableName != null) {
             String occurrenceName =
-                occurence._parameterOldToOccurrenceName[_returnVariableName];
+                occurrence._parameterOldToOccurrenceName[_returnVariableName];
             // may be declare variable
             if (!_parametersMap.containsKey(_returnVariableName)) {
               if (variableType.isEmpty) {
                 sb.write('var ');
               } else {
                 sb.write(variableType);
                 sb.write(' ');
               }
             }
             // assign the return value
@@ skipping 15 matching lines @@
           for (RefactoringMethodParameter parameter in _parameters) {
             // may be comma
             if (firstParameter) {
               firstParameter = false;
             } else {
               sb.write(', ');
             }
             // argument name
             {
               String argumentName =
-                  occurence._parameterOldToOccurrenceName[parameter.id];
+                  occurrence._parameterOldToOccurrenceName[parameter.id];
               sb.write(argumentName);
             }
           }
           sb.write(')');
         }
         invocationSource = sb.toString();
         // statements as extracted with their ";", so add new after invocation
         if (_selectionStatements != null) {
           invocationSource += ';';
         }
@@ skipping 14 matching lines @@
         if (_staticContext) {
           annotations = 'static ';
         }
       }
       // prepare declaration source
       String declarationSource = null;
       {
         String returnExpressionSource = _getMethodBodySource();
         // closure
         if (_selectionFunctionExpression != null) {
-          declarationSource = '${name}${returnExpressionSource}';
+          declarationSource = '$name$returnExpressionSource';
           if (_selectionFunctionExpression.body is ExpressionFunctionBody) {
             declarationSource += ';';
           }
         }
         // optional 'async' body modifier
         String asyncKeyword = _hasAwait ? ' async' : '';
         // expression
         if (_selectionExpression != null) {
           // add return type
           if (returnType.isNotEmpty) {
             annotations += '$returnType ';
           }
           // just return expression
           declarationSource = '$annotations$signature$asyncKeyword => ';
           declarationSource += '$returnExpressionSource;';
         }
         // statements
         if (_selectionStatements != null) {
           if (returnType.isNotEmpty) {
             annotations += returnType + ' ';
           }
           declarationSource = '$annotations$signature$asyncKeyword {$eol';
           declarationSource += returnExpressionSource;
           if (_returnVariableName != null) {
             declarationSource +=
-                '${prefix}  return ${_returnVariableName};$eol';
+                '$prefix  return $_returnVariableName;$eol';
           }
-          declarationSource += '${prefix}}';
+          declarationSource += '$prefix}';
         }
       }
       // insert declaration
       if (declarationSource != null) {
         int offset = _parentMember.end;
         SourceEdit edit = new SourceEdit(
-            offset, 0, '${eol}${eol}${prefix}${declarationSource}');
+            offset, 0, '$eol$eol$prefix$declarationSource');
         doSourceChange_addElementEdit(change, unitElement, edit);
       }
     }
     // done
     addLibraryImports(change, libraryElement, librariesToImport);
     return change;
   }
 
   @override
   bool requiresPreview() => false;
@@ skipping 855 matching lines @@
       return false;
     }
     for (int i = 0; i < parameterTypes.length; i++) {
       if (other.parameterTypes[i] != parameterTypes[i]) {
         return false;
       }
     }
     return true;
   }
 }