datatype()s can declare default values

src/python/pants/base/project_tree.py

@@ -212,19 +212,10 @@ def path(self):
 class File(datatype(['path']), Stat):
   """A file."""
 
-  def __new__(cls, path):
-    return super(File, cls).__new__(cls, path)
-
 
 class Dir(datatype(['path']), Stat):
   """A directory."""
 
-  def __new__(cls, path):
-    return super(Dir, cls).__new__(cls, path)
-
 
 class Link(datatype(['path']), Stat):
   """A symbolic link."""
-
-  def __new__(cls, path):
-    return super(Link, cls).__new__(cls, path)

src/python/pants/base/specs.py

@@ -8,6 +8,7 @@
 from abc import abstractmethod
 
 from pants.util.meta import AbstractClass
+from pants.util.objects import DatatypeFieldDecl as F
 from pants.util.objects import datatype
 
 
@@ -60,11 +61,11 @@ def to_spec_string(self):
     return '{}^'.format(self.directory)
 
 
-class Specs(datatype(['dependencies', 'tags', ('exclude_patterns', tuple)])):
+class Specs(datatype([
+    'dependencies',
+    F('tags', tuple, default_value=()),
+    F('exclude_patterns', tuple, default_value=())])):
   """A collection of Specs representing Spec subclasses, tags and regex filters."""
 
-  def __new__(cls, dependencies, tags=tuple(), exclude_patterns=tuple()):
-    return super(Specs, cls).__new__(cls, dependencies, tags, exclude_patterns)
-
   def exclude_patterns_memo(self):
     return [re.compile(pattern) for pattern in set(self.exclude_patterns or [])]

src/python/pants/engine/isolated_process.py

@@ -11,6 +11,7 @@
 from pants.engine.fs import DirectoryDigest
 from pants.engine.rules import RootRule, rule
 from pants.engine.selectors import Select
+from pants.util.objects import DatatypeFieldDecl as F
 from pants.util.objects import Exactly, TypeCheckError, datatype
 
 
@@ -23,28 +24,25 @@ class ExecuteProcessRequest(datatype([
   ('argv', tuple),
   ('input_files', DirectoryDigest),
   ('description', text_type),
-  ('env', tuple),
-  ('output_files', tuple),
-  ('output_directories', tuple),
+  # TODO: allow inferring a default value if a type is provided which has a 0-arg constructor.
+  F('env', Exactly(tuple, dict, type(None)), default_value=None),
+  F('output_files', tuple, default_value=()),
+  F('output_directories', tuple, default_value=()),
   # NB: timeout_seconds covers the whole remote operation including queuing and setup.
-  ('timeout_seconds', Exactly(float, int)),
-  ('jdk_home', Exactly(text_type, type(None))),
+  F('timeout_seconds', Exactly(float, int), default_value=_default_timeout_seconds),
+  F('jdk_home', Exactly(text_type, type(None)), default_value=None),
 ])):
   """Request for execution with args and snapshots to extract."""
 
-  def __new__(
-    cls,
-    argv,
-    input_files,
-    description,
-    env=None,
-    output_files=(),
-    output_directories=(),
-    timeout_seconds=_default_timeout_seconds,
-    jdk_home=None,
-  ):
+  def __new__(cls, *args, **kwargs):
+    this_object = super(ExecuteProcessRequest, cls).__new__(cls, *args, **kwargs)
+
+    env = this_object.env
+    # `env` is a tuple, a dict, or None.
     if env is None:
       env = ()
+    elif isinstance(env, tuple):
+      pass
     else:
       if not isinstance(env, dict):
         raise TypeCheckError(
@@ -56,17 +54,7 @@ def __new__(
         )
       env = tuple(item for pair in env.items() for item in pair)
 
-    return super(ExecuteProcessRequest, cls).__new__(
-      cls,
-      argv=argv,
-      env=env,
-      input_files=input_files,
-      description=description,
-      output_files=output_files,
-      output_directories=output_directories,
-      timeout_seconds=timeout_seconds,
-      jdk_home=jdk_home,
-    )
+    return this_object.copy(env=env)
 
 
 class ExecuteProcessResult(datatype([('stdout', binary_type),

src/python/pants/engine/selectors.py

@@ -11,7 +11,8 @@
 import six
 
 from pants.util.meta import AbstractClass
-from pants.util.objects import Exactly, datatype
+from pants.util.objects import DatatypeFieldDecl as F
+from pants.util.objects import Exactly, SubclassesOf, datatype
 
 
 def type_or_constraint_repr(constraint):
@@ -96,23 +97,25 @@ def product(self):
     """The product that this selector produces."""
 
 
-class Select(datatype(['product', 'optional']), Selector):
+class Select(datatype([
+    'product',
+    F('optional', bool, default_value=False),
+]), Selector):
   """Selects the given Product for the Subject provided to the constructor.
 
   If optional=True and no matching product can be produced, will return None.
   """
 
-  def __new__(cls, product, optional=False):
-    obj = super(Select, cls).__new__(cls, product, optional)
-    return obj
-
   def __repr__(self):
     return '{}({}{})'.format(type(self).__name__,
                              type_or_constraint_repr(self.product),
                              ', optional=True' if self.optional else '')
 
 
-class SelectVariant(datatype(['product', 'variant_key']), Selector):
+class SelectVariant(datatype([
+    'product',
+    ('variant_key', SubclassesOf(*six.string_types)),
+]), Selector):
   """Selects the matching Product and variant name for the Subject provided to the constructor.
 
   For example: a SelectVariant with a variant_key of "thrift" and a product of type ApacheThrift
@@ -121,11 +124,6 @@ class SelectVariant(datatype(['product', 'variant_key']), Selector):
   """
   optional = False
 
-  def __new__(cls, product, variant_key):
-    if not isinstance(variant_key, six.string_types):
-      raise ValueError('Expected variant_key to be a string, but was {!r}'.format(variant_key))
-    return super(SelectVariant, cls).__new__(cls, product, variant_key)
-
   def __repr__(self):
     return '{}({}, {})'.format(type(self).__name__,
                                type_or_constraint_repr(self.product),

src/python/pants/option/scope.py

@@ -4,15 +4,15 @@
 
 from __future__ import absolute_import, division, print_function, unicode_literals
 
-from collections import namedtuple
+from pants.util.objects import DatatypeFieldDecl as F
+from pants.util.objects import datatype
 
 
 GLOBAL_SCOPE = ''
 GLOBAL_SCOPE_CONFIG_SECTION = 'GLOBAL'
 
 
-# FIXME: convert this to a datatype?
-class ScopeInfo(namedtuple('_ScopeInfo', ['scope', 'category', 'optionable_cls'])):
+class ScopeInfo(datatype(['scope', 'category', F('optionable_cls', default_value=None)])):
   """Information about a scope."""
 
   # Symbolic constants for different categories of scope.
@@ -36,7 +36,3 @@ def deprecated_scope_removal_version(self):
 
   def _optionable_cls_attr(self, name, default=None):
     return getattr(self.optionable_cls, name) if self.optionable_cls else default
-
-
-# Allow the optionable_cls to default to None.
-ScopeInfo.__new__.__defaults__ = (None, )