For c++, Generate enum classes instead of enum from mojom.

mojo/public/tools/bindings/generators/mojom_cpp_generator.py

Index: mojo/public/tools/bindings/generators/mojom_cpp_generator.py
diff --git a/mojo/public/tools/bindings/generators/mojom_cpp_generator.py b/mojo/public/tools/bindings/generators/mojom_cpp_generator.py
index ff673bc9f776160352b8b3afb3034c81b19680c2..f0fda1ed7b3d8cb5089f107808a30518ac2faa8c 100644
--- a/mojo/public/tools/bindings/generators/mojom_cpp_generator.py
+++ b/mojo/public/tools/bindings/generators/mojom_cpp_generator.py
@@ -53,6 +53,9 @@ def DefaultValue(field):
     return ExpressionToText(field.default, kind=field.kind)
   return ""
 
+def IsEnumToken(token):
+  return isinstance(token, mojom.EnumValue)
+
 def NamespaceToArray(namespace):
   return namespace.split(".") if namespace else []
 
@@ -265,12 +268,21 @@ def TranslateConstants(token, kind):
       name.extend(NamespaceToArray(token.namespace))
     if token.parent_kind:
       name.append(token.parent_kind.name)
-    if isinstance(token, mojom.EnumValue):
-      name.append(
-          "%s_%s" % (generator.CamelCaseToAllCaps(token.enum.name), token.name))
+    if IsEnumToken(token):
+      name.extend([token.enum.name, token.name])
     else:
       name.append(token.name)
-    return "::".join(name)
+
+    ret = "::".join(name)
+
+    # If we are translating an enum token for a non-enum (but defined) kind, or
+    # a non-enum token for an enum kind, we need an explicit cast.
+    # TODO(johngro) : should this be allowed at all?

[viettrungluu, 2015/10/01 17:49:55]

Are we using this? Are there test cases?

[johngro, 2015/10/02 00:49:04]

Unclear, and sort of.

"Are we using this?"
To accomplish useful things?  I don't know.  The code path is exercised by the
build, however.

"Are there test cases?"
There is mojo/public/interfaces/bindings/tests/test_structs.mojom which
exercises the first half of the check when it says..

struct ScopedConstants {
  const int32 TEN = 10;
  const int32 ALSO_TEN = TEN;
  enum EType {
    E0,
    E1,
    E2 = 10,
    E3 = E2,
    E4,
  };
  const int32 TEN_TOO = EType.E2;
  EType f0 = E0; // 0
  EType f1 = E1; // 1
  EType f2 = E2; // 10
  EType f3 = E3; // 10
  EType f4 = E4; // 11
  int32 f5 = TEN;
  int32 f6 = ALSO_TEN;
};

The assignment of the token EType.E2 to the const int32 TEN_TOO results in the
assignment of an enum token (EType.E2) to a non-None, non-Enum kind (int32). 
Generated code requires that a cast be synthesized in this case.

This is currently permitted by the binding generator, and appears to be
permitted by the mojom grammar.  Whether or not it should be is above my pay
grade, which is why I left the question in the comment.

Regarding the second half...  The following statement is considered to be legal
by the current toolchain as well...

struct ScopedConstants {
  ...
  EType f7 = ScopedConstants.TEN;
  ...
};

Since the token (ScopedConstants.TEN) is a named value, and it is of non enum
type, and the kind it is being assigned to is of enum kind, a cast must be
generated.

Note:
  EType f7 = TEN;
will generate an exception.  So will
  const EType blah = Etype.E2;

Similar syntax when dealing with ints, and non-const enum types are permitted,
so this feels like a bug.  For example
  const int32 TEN_TOO = EType.E2; // legal
  const EType TEN_TOO = Etype.E2; // exception
  int32 TEN_TOO = 10; // legal
  EType TEN_TOO = 10; // legal
  int32 TEN_TOO = TEN; // legal
  EType TEN_TOO = TEN; // exception
  int32 TEN_TOO = ScopedConstants.TEN; // legal
  EType TEN_TOO = ScopedConstants.TEN; // legal

So: "Are there tests for this?"
Again sort of.  There is a test for the first half of this check in
test_structs.mojom.  The second half can be legally exercised using the
currently permitted test, but there does not seem to be an explicit test for it.
 Until the question of "should this be allowed at all" is resolved, I am
reluctant to update the tests.  If the answer is yes, then all of the issues
with exceptions when parsing apparently legal syntax need to be resolved and the
tests updated appropriately by the individual who implements the fix.  If the
answer is no, then in addition to updating the toolchain to explicitly disallow
this syntax, different tests need to be written to make sure that the syntax is
enforced.

+    if IsEnumToken(token) and (None != kind) and (not mojom.IsEnumKind(kind)):

[viettrungluu, 2015/10/01 17:49:55]

Can |kind| really be None?

Side points:
* Drop the unneeded parentheses.
* |kind is not None|, not |kind != None| (which would still be preferable to
|None != kind|.

[johngro, 2015/10/02 00:49:04]

Yes.  In addition to the implication of the function defined immediately
following this one as...

def ExpressionToText(value, kind=None):
  return TranslateConstants(value, kind)

There is the common case of assigning a constant value (named or not) to a
member of an enumeration.  In the case that the target is the declaration of a
member of an enumeration (not an instance of one), kind appears to be None.  For
example..

enum MyEnum {
 A = 10,
 B = A,
}

Both result in Kind == none.  There may be other cases, but I am unaware of
them.

 
done.

+      return "static_cast<int32_t>(%s)" % (ret, )
+    elif not IsEnumToken(token) and mojom.IsEnumKind(kind):
+      return "static_cast<%s>(%s)" % (GetNameForKind(kind), ret)
+    return ret
 
   if isinstance(token, mojom.BuiltinValue):
     if token.value == "double.INFINITY" or token.value == "float.INFINITY":
@@ -299,7 +311,13 @@ def TranslateConstants(token, kind):
     return "(-%d - 1) /* %s */" % (
         2**31 - 1, "Workaround for MSVC bug; see https://crbug.com/445618")
 
-  return "%s%s" % (token, _kind_to_cpp_literal_suffix.get(kind, ""))
+
+  # If we are translating a literal for an enum kind, we need an explicit cast.
+  # TODO(johngro) : should this be allowed at all?
+  ret = "%s%s" % (token, _kind_to_cpp_literal_suffix.get(kind, ""))
+  if mojom.IsEnumKind(kind):
+      return "static_cast<%s>(%s)" % (GetNameForKind(kind), ret)
+  return ret
 
 def ExpressionToText(value, kind=None):
   return TranslateConstants(value, kind)