Remove the name field from the PredNode union type.

The name of a predicate was only ever used for named settings that are
computed as a boolean expression of other settings.

- Record the names of these settings in named_predicates instead.
- Remove the name field from all predicates.

Named predicates does not interact well with the interning of predicates
through isa.unique_pred().

lib/cretonne/meta/cdsl/predicates.py

@@ -80,7 +80,6 @@ class Predicate(object):
 
     def __init__(self, parts):
         # type: (Sequence[PredNode]) -> None
-        self.name = None  # type: str
         self.number = None  # type: int
         self.parts = parts
         self.context = reduce(
@@ -91,12 +90,8 @@ class Predicate(object):
 
     def __str__(self):
         # type: () -> str
-        if self.name:
+        return '{}({})'.format(type(self).__name__,
-            return '{}.{}'.format(self.context.name, self.name)
+                               ', '.join(map(str, self.parts)))
-        else:
-            return '{}({})'.format(
-                    type(self).__name__,
-                    ', '.join(map(str, self.parts)))
 
     def predicate_context(self):
         # type: () -> PredContext
@@ -219,8 +214,6 @@ class FieldPredicate(object):
         self.field = field
         self.function = function
         self.args = args
-        # All PredNode members must have a name field. This will never be set.
-        self.name = None  # type: str
 
     def __str__(self):
         # type: () -> str
@@ -338,8 +331,6 @@ class TypePredicate(object):
         self.value_arg = value_arg
         self.value_type = value_type
         self.number = None  # type: int
-        # All PredNode members must have a name field. This will never be set.
-        self.name = None  # type: str
 
     def __str__(self):
         # type: () -> str

lib/cretonne/meta/cdsl/settings.py

@@ -190,7 +190,7 @@ class SettingGroup(object):
         self.settings = []  # type: List[Setting]
         # Named predicates computed from settings in this group or its
         # parents.
-        self.named_predicates = []  # type: List[Predicate]
+        self.named_predicates = OrderedDict()  # type: OrderedDict[str, Predicate]  # noqa
         # All boolean predicates that can be accessed by number. This includes:
         # - All boolean settings in this group.
         # - All named predicates.
@@ -235,9 +235,7 @@ class SettingGroup(object):
                     assert obj.name is None, obj.name
                     obj.name = name
                 if isinstance(obj, Predicate):
-                    assert obj.name is None
+                    self.named_predicates[name] = obj
-                    obj.name = name
-                    self.named_predicates.append(obj)
                 if isinstance(obj, Preset):
                     assert obj.name is None, obj.name
                     obj.name = name
@@ -333,8 +331,8 @@ class SettingGroup(object):
         self.settings_size = self.byte_size()
 
         # Now assign numbers to all our named predicates.
-        for p in self.named_predicates:
+        for name, pred in self.named_predicates.items():
-            self.number_predicate(p)
+            self.number_predicate(pred)
 
     def byte_size(self):
         # type: () -> int

lib/cretonne/meta/gen_settings.py

@@ -67,13 +67,13 @@ def gen_getter(setting, sgrp, fmt):
         raise AssertionError("Unknown setting kind")
 
 
-def gen_pred_getter(pred, sgrp, fmt):
+def gen_pred_getter(name, pred, sgrp, fmt):
-    # type: (Predicate, SettingGroup, srcgen.Formatter) -> None
+    # type: (str, Predicate, SettingGroup, srcgen.Formatter) -> None
     """
-    Emit a getter for a pre-computed predicate.
+    Emit a getter for a named pre-computed predicate.
     """
     fmt.doc_comment('Computed predicate `{}`.'.format(pred.rust_predicate(0)))
-    proto = 'pub fn {}(&self) -> bool'.format(pred.name)
+    proto = 'pub fn {}(&self) -> bool'.format(name)
     with fmt.indented(proto + ' {', '}'):
         fmt.line(
                 'self.numbered_predicate({})'
@@ -103,8 +103,8 @@ def gen_getters(sgrp, fmt):
                         .format(sgrp.boolean_offset))
         for setting in sgrp.settings:
             gen_getter(setting, sgrp, fmt)
-        for pred in sgrp.named_predicates:
+        for name, pred in sgrp.named_predicates.items():
-            gen_pred_getter(pred, sgrp, fmt)
+            gen_pred_getter(name, pred, sgrp, fmt)
 
 
 def gen_descriptors(sgrp, fmt):
@@ -262,11 +262,7 @@ def gen_constructor(sgrp, parent, fmt):
                 # Don't compute our own settings.
                 if number < sgrp.boolean_settings:
                     continue
-                if pred.name:
+                fmt.comment('Precompute #{}.'.format(number))
-                    fmt.comment(
-                            'Precompute #{} ({}).'.format(number, pred.name))
-                else:
-                    fmt.comment('Precompute #{}.'.format(number))
                 with fmt.indented(
                         'if {} {{'.format(pred.rust_predicate(0)),
                         '}'):