Fix lints: unnecessary_brace_in_string_interp

pkg/analysis_server/lib/src/services/correction/util.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.correction.util;
 
 import 'dart:math';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart'
     show SourceChange, SourceEdit;
@@ skipping 708 matching lines @@
           directive is ExportDirective) {
         prevDirective = directive;
       }
     }
     // insert after last library-related directive
     if (prevDirective != null) {
       CorrectionUtils_InsertDesc result = new CorrectionUtils_InsertDesc();
       result.offset = prevDirective.end;
       String eol = endOfLine;
       if (prevDirective is LibraryDirective) {
-        result.prefix = "${eol}${eol}";
+        result.prefix = "$eol$eol";
       } else {
         result.prefix = eol;
       }
       return result;
     }
     // no directives, use "top" location
     return getInsertDescTop();
   }
 
   /**
    * Returns a [InsertDesc] describing where to insert a new 'part' directive.
    */
   CorrectionUtils_InsertDesc getInsertDescPart() {
     // analyze directives
     Directive prevDirective = null;
     for (Directive directive in unit.directives) {
       prevDirective = directive;
     }
     // insert after last directive
     if (prevDirective != null) {
       CorrectionUtils_InsertDesc result = new CorrectionUtils_InsertDesc();
       result.offset = prevDirective.end;
       String eol = endOfLine;
       if (prevDirective is PartDirective) {
         result.prefix = eol;
       } else {
-        result.prefix = "${eol}${eol}";
+        result.prefix = "$eol$eol";
       }
       return result;
     }
     // no directives, use "top" location
     return getInsertDescTop();
   }
 
   /**
    * Returns a [InsertDesc] describing where to insert a new directive or a
    * top-level declaration at the top of the file.
@@ skipping 359 matching lines @@
     String eol = endOfLine;
     List<String> lines = source.split(eol);
     for (int i = 0; i < lines.length; i++) {
       String line = lines[i];
       // last line, stop if empty
       if (i == lines.length - 1 && isEmpty(line)) {
         break;
       }
       // update line
       if (right) {
-        line = "${indent}${line}";
+        line = "$indent$line";
       } else {
         line = removeStart(line, indent);
       }
       // append line
       sb.write(line);
       sb.write(eol);
     }
     return sb.toString();
   }
 
@@ skipping 50 matching lines @@
         if (lineOffset > lineRange.offset && lineOffset < lineRange.end) {
           inString = true;
         }
         if (lineOffset > lineRange.end) {
           break;
         }
       }
       lineOffset += line.length + eol.length;
       // update line indent
       if (!inString) {
-        line = "${newIndent}${removeStart(line, oldIndent)}";
+        line = "$newIndent${removeStart(line, oldIndent)}";
       }
       // append line
       sb.write(line);
       sb.write(eol);
     }
     return sb.toString();
   }
 
   /**
    * Returns the source of the given [SourceRange] with indentation changed
@@ skipping 75 matching lines @@
         return _InvertedCondition._binary(
             TokenType.AMPERSAND_AMPERSAND.precedence, ls, " && ", rs);
       }
     }
     if (expression is IsExpression) {
       IsExpression isExpression = expression;
       String expressionSource = getNodeText(isExpression.expression);
       String typeSource = getNodeText(isExpression.type);
       if (isExpression.notOperator == null) {
         return _InvertedCondition
-            ._simple("${expressionSource} is! ${typeSource}");
+            ._simple("$expressionSource is! $typeSource");
       } else {
         return _InvertedCondition
-            ._simple("${expressionSource} is ${typeSource}");
+            ._simple("$expressionSource is $typeSource");
       }
     }
     if (expression is PrefixExpression) {
       PrefixExpression prefixExpression = expression;
       TokenType operator = prefixExpression.operator.type;
       if (operator == TokenType.BANG) {
         Expression operand = prefixExpression.operand;
         while (operand is ParenthesizedExpression) {
           ParenthesizedExpression pe = operand as ParenthesizedExpression;
           operand = pe.expression;
@@ skipping 136 matching lines @@
     String src = _parenthesizeIfRequired(left, precedence) +
         operation +
         _parenthesizeIfRequired(right, precedence);
     return new _InvertedCondition(precedence, src);
   }
 
   static _InvertedCondition _binary2(
       _InvertedCondition left, String operation, _InvertedCondition right) {
     // TODO(scheglov) consider merging with "_binary()" after testing
     return new _InvertedCondition(
-        1 << 20, "${left._source}${operation}${right._source}");
+        1 << 20, "${left._source}$operation${right._source}");
   }
 
   /**
    * Adds enclosing parenthesis if the precedence of the [_InvertedCondition] if less than the
    * precedence of the expression we are going it to use in.
    */
   static String _parenthesizeIfRequired(
       _InvertedCondition expr, int newOperatorPrecedence) {
     if (expr._precedence < newOperatorPrecedence) {
       return "(${expr._source})";
     }
     return expr._source;
   }
 
   static _InvertedCondition _simple(String source) =>
       new _InvertedCondition(2147483647, source);
 }