Mojo: add support for {double,float}.{INFINITY,NEGATIVE_INFINITY,NAN}

mojo/public/tools/bindings/pylib/mojom/generate/data.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # TODO(vtl): "data" is a pretty vague name. Rename it?
 
 import copy
 
 import module as mojom
 
@@ skipping 24 matching lines @@
 # pretty printing maintain the order.
 def istr(index, string):
   class IndexedString(str):
     def __lt__(self, other):
       return self.__index__ < other.__index__
 
   rv = IndexedString(string)
   rv.__index__ = index
   return rv
 
+builtin_values = frozenset([
+    "double.INFINITY",
+    "double.NEGATIVE_INFINITY",
+    "double.NAN",
+    "float.INFINITY",
+    "float.NEGATIVE_INFINITY",
+    "float.NAN"])
+
+def IsBuiltinValue(value):
+  return value in builtin_values
+
 def LookupKind(kinds, spec, scope):
   """Tries to find which Kind a spec refers to, given the scope in which its
   referenced. Starts checking from the narrowest scope to most general. For
   example, given a struct field like
     Foo.Bar x;
   Foo.Bar could refer to the type 'Bar' in the 'Foo' namespace, or an inner
   type 'Bar' in the struct 'Foo' in the current namespace.
 
   |scope| is a tuple that looks like (namespace, struct/interface), referring
   to the location where the type is referenced."""
@@ skipping 23 matching lines @@
     if test_spec:
       test_spec += '.'
     test_spec += name
     value = values.get(test_spec)
     if value:
       return value
 
   return values.get(name)
 
 def FixupExpression(module, value, scope, kind):
-  """Translates an IDENTIFIER into a structured Value object."""
+  """Translates an IDENTIFIER into a built-in value or structured NamedValue
+     object."""
   if isinstance(value, tuple) and value[0] == 'IDENTIFIER':
+    # Allow user defined values to shadow builtins.
     result = LookupValue(module.values, value[1], scope, kind)
     if result:
       return result
+    if IsBuiltinValue(value[1]):
+      return mojom.BuiltinValue(value[1])
   return value
 
 def KindToData(kind):
   return kind.spec
 
 def KindFromData(kinds, data, scope):
   kind = LookupKind(kinds, data, scope)
   if kind:
     return kind
 
@@ skipping 247 matching lines @@
 
 def OrderedModuleFromData(data):
   module = ModuleFromData(data)
   for interface in module.interfaces:
     next_ordinal = 0
     for method in interface.methods:
       if method.ordinal is None:
         method.ordinal = next_ordinal
       next_ordinal = method.ordinal + 1
   return module