Fix summary resynthesis for operators ending in '='.

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

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 1268 matching lines @@
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, null, null, 'C');
     expect(executable.typeParameters, isEmpty);
     expect(executable.isExternal, false);
   }
 
+  test_executable_operator_equal() {
+    UnlinkedExecutable executable =
+        serializeClassText('class C { bool operator==(C other) => false; }')
+            .executables[0];
+    expect(executable.name, '==');
+  }
+
   test_executable_operator_external() {
     UnlinkedExecutable executable =
         serializeClassText('class C { external C operator+(C c); }')
             .executables[0];
     expect(executable.isExternal, true);
   }
 
+  test_executable_operator_greater_equal() {
+    UnlinkedExecutable executable =
+        serializeClassText('class C { bool operator>=(C other) => false; }')
+            .executables[0];
+    expect(executable.name, '>=');
+  }
+
   test_executable_operator_index() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator[](int i) => null; }')
             .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
@@ skipping 11 matching lines @@
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     expect(executable.returnType, isNull);
     expect(executable.typeParameters, isEmpty);
   }
 
+  test_executable_operator_less_equal() {
+    UnlinkedExecutable executable =
+        serializeClassText('class C { bool operator<=(C other) => false; }')
+            .executables[0];
+    expect(executable.name, '<=');
+  }
+
   test_executable_param_function_typed() {
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].isFunctionTyped, isTrue);
     // Since the parameter is function-typed it is considered to have an
     // explicit type, even though that explicit type itself has an implicit
     // return type.
     expect(executable.parameters[0].hasImplicitType, isFalse);
   }
 
   test_executable_param_function_typed_explicit_return_type() {
@@ skipping 767 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 }