Parenthesize expressions as needed in elements text dump.

pkg/analyzer/test/src/summary/element_text.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:io';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 251 matching lines @@
   void writeExportElement(ExportElement e) {
     writeMetadata(e, '', '\n');
     buffer.write('export ');
     writeUri(e.exportedLibrary?.source);
 
     e.combinators.forEach(writeNamespaceCombinator);
 
     buffer.writeln(';');
   }
 
-  void writeExpression(AstNode e) {
+  void writeExpression(AstNode e, [Expression enclosing]) {
+    bool needsParenthesis = e is Expression &&
+        enclosing != null &&
+        e.precedence < enclosing.precedence;
+
+    if (needsParenthesis) {
+      buffer.write('(');
+    }
+
     if (e is Annotation) {
       buffer.write('@');
       writeExpression(e.name);
       if (e.constructorName != null) {
         buffer.write('.');
         writeExpression(e.constructorName);
       }
       if (e.arguments != null) {
         writeList('(', ')', e.arguments.arguments, ', ', writeExpression,
             includeEmpty: true);
       }
     } else if (e is AssertInitializer) {
       buffer.write('assert(');
       writeExpression(e.condition);
       if (e.message != null) {
         buffer.write(', ');
         writeExpression(e.message);
       }
       buffer.write(')');
     } else if (e is BinaryExpression) {
-      writeExpression(e.leftOperand);
+      writeExpression(e.leftOperand, e);
       buffer.write(' ');
       buffer.write(e.operator.lexeme);
       buffer.write(' ');
-      writeExpression(e.rightOperand);
+      writeExpression(e.rightOperand, e);
     } else if (e is BooleanLiteral) {
       buffer.write(e.value);
     } else if (e is ConditionalExpression) {
       writeExpression(e.condition);
       buffer.write(' ? ');
       writeExpression(e.thenExpression);
       buffer.write(' : ');
       writeExpression(e.elseExpression);
     } else if (e is ConstructorFieldInitializer) {
       writeExpression(e.fieldName);
@@ skipping 45 matching lines @@
       writeExpression(e.key);
       buffer.write(': ');
       writeExpression(e.value);
     } else if (e is NamedExpression) {
       writeExpression(e.name);
       buffer.write(e.expression);
     } else if (e is NullLiteral) {
       buffer.write('null');
     } else if (e is PrefixExpression) {
       buffer.write(e.operator.lexeme);
-      writeExpression(e.operand);
+      writeExpression(e.operand, e);
     } else if (e is PrefixedIdentifier) {
       writeExpression(e.prefix);
       buffer.write('.');
       writeExpression(e.identifier);
     } else if (e is PropertyAccess) {
-      writeExpression(e.target);
+      writeExpression(e.target, e);
       buffer.write('.');
       writeExpression(e.propertyName);
     } else if (e is RedirectingConstructorInvocation) {
       buffer.write('this');
       if (e.constructorName != null) {
         buffer.write('.');
         writeExpression(e.constructorName);
       }
       writeList('(', ')', e.argumentList.arguments, ', ', writeExpression,
           includeEmpty: true);
@@ skipping 34 matching lines @@
     } else if (e is ThisExpression) {
       buffer.write('this');
     } else if (e is TypeName) {
       writeExpression(e.name);
       if (e.typeArguments != null) {
         writeList('<', '>', e.typeArguments.arguments, ', ', writeExpression);
       }
     } else {
       fail('Unsupported expression type: ${e.runtimeType}');
     }
+
+    if (needsParenthesis) {
+      buffer.write(')');
+    }
   }
 
   void writeFunctionElement(FunctionElement e) {
     writeDocumentation(e);
     writeMetadata(e, '', '\n');
 
     writeIf(e.isExternal, 'external ');
 
     writeType2(e.returnType);
 
@@ skipping 424 matching lines @@
     return components.join(';');
   }
 }
 
 class _Replacement {
   final int offset;
   final int end;
   final String text;
   _Replacement(this.offset, this.end, this.text);
 }