Support serialization of the compiler backbone.

pkg/compiler/lib/src/resolution/operators.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 dart2js.operators;
 
 import '../elements/elements.dart';
 import '../universe/universe.dart';
 
 enum UnaryOperatorKind {
@@ skipping 31 matching lines @@
       const UnaryOperator(UnaryOperatorKind.COMPLEMENT, '~', '~');
 
   static UnaryOperator parse(String value) {
     switch (value) {
       case '!': return NOT;
       case '-': return NEGATE;
       case '~': return COMPLEMENT;
       default: return null;
     }
   }
+
+  static UnaryOperator fromKind(UnaryOperatorKind kind) {
+    switch (kind) {
+      case UnaryOperatorKind.NOT: return NOT;
+      case UnaryOperatorKind.NEGATE: return NEGATE;
+      case UnaryOperatorKind.COMPLEMENT: return COMPLEMENT;
+    }
+  }
 }
 
 enum BinaryOperatorKind {
   EQ,
   NOT_EQ,
   INDEX,
   ADD,
   SUB,
   MUL,
   DIV,
@@ skipping 129 matching lines @@
       case '<': return LT;
       case '&': return AND;
       case '^': return XOR;
       case '|': return OR;
       case '&&': return LOGICAL_AND;
       case '||': return LOGICAL_OR;
       case '??': return IF_NULL;
       default: return null;
     }
   }
+
+  static BinaryOperator fromKind(BinaryOperatorKind kind) {
+    switch (kind) {
+      case BinaryOperatorKind.EQ: return EQ;
+      case BinaryOperatorKind.NOT_EQ: return NOT_EQ;
+      case BinaryOperatorKind.INDEX: return INDEX;
+      case BinaryOperatorKind.MUL: return MUL;
+      case BinaryOperatorKind.DIV: return DIV;
+      case BinaryOperatorKind.MOD: return MOD;
+      case BinaryOperatorKind.IDIV: return IDIV;
+      case BinaryOperatorKind.ADD: return ADD;
+      case BinaryOperatorKind.SUB: return SUB;
+      case BinaryOperatorKind.SHL: return SHL;
+      case BinaryOperatorKind.SHR: return SHR;
+      case BinaryOperatorKind.GTEQ: return GTEQ;
+      case BinaryOperatorKind.GT: return GT;
+      case BinaryOperatorKind.LTEQ: return LTEQ;
+      case BinaryOperatorKind.LT: return LT;
+      case BinaryOperatorKind.AND: return AND;
+      case BinaryOperatorKind.XOR: return XOR;
+      case BinaryOperatorKind.OR: return OR;
+      case BinaryOperatorKind.LOGICAL_AND: return LOGICAL_AND;
+      case BinaryOperatorKind.LOGICAL_OR: return LOGICAL_OR;
+      case BinaryOperatorKind.IF_NULL: return IF_NULL;
+    }
+  }
 }
 
 /// The operator !=, which is not user definable operator but instead is a
 /// negation of a call to user definable operator, namely ==.
 class _NotEqualsOperator extends BinaryOperator {
   const _NotEqualsOperator() : super._(BinaryOperatorKind.NOT_EQ, '!=');
 
   bool get isUserDefinable => false;
 
   String get selectorName => '==';
@@ skipping 162 matching lines @@
       const IncDecOperator._(IncDecOperatorKind.DEC, '--', BinaryOperator.SUB);
 
   static IncDecOperator parse(String value) {
     switch (value) {
       case '++': return INC;
       case '--': return DEC;
       default: return null;
     }
   }
 }