Concretize preserves deptypes (#2681)

Concretization preserves deptypes

7 files changed, 326 insertions, 179 deletions

diff --git a/lib/spack/spack/__init__.py b/lib/spack/spack/__init__.py
index fcf140617e..39a0b78f82 100644
--- a/lib/spack/spack/__init__.py
+++ b/lib/spack/spack/__init__.py
@@ -158,23 +158,22 @@ dirty = _config.get('dirty', False)
 #       for packages.
 #
 #-----------------------------------------------------------------------------
-__all__ = ['PackageBase',
-           'Package',
-           'CMakePackage',
-           'AutotoolsPackage',
-           'MakefilePackage',
-           'Version',
-           'when',
-           'ver',
-           'alldeps',
-           'nolink']
-from spack.package import Package, PackageBase, ExtensionConflictError
+__all__ = []
+
+from spack.package import Package
 from spack.build_systems.makefile import MakefilePackage
 from spack.build_systems.autotools import AutotoolsPackage
 from spack.build_systems.cmake import CMakePackage
+__all__ += ['Package', 'CMakePackage', 'AutotoolsPackage', 'MakefilePackage']
+
 from spack.version import Version, ver
-from spack.spec import DependencySpec, alldeps, nolink
+__all__ += ['Version', 'ver']
+
+from spack.spec import Spec, alldeps, nolink
+__all__ += ['Spec', 'alldeps', 'nolink']
+
 from spack.multimethod import when
+__all__ += ['when']
 
 import llnl.util.filesystem
 from llnl.util.filesystem import *
diff --git a/lib/spack/spack/cmd/graph.py b/lib/spack/spack/cmd/graph.py
index f9011caef4..6a268e6961 100644
--- a/lib/spack/spack/cmd/graph.py
+++ b/lib/spack/spack/cmd/graph.py
@@ -84,7 +84,7 @@ def graph(parser, args):
         setup_parser.parser.print_help()
         return 1
 
-    deptype = nobuild
+    deptype = alldeps
     if args.deptype:
         deptype = tuple(args.deptype.split(','))
         validate_deptype(deptype)
diff --git a/lib/spack/spack/graph.py b/lib/spack/spack/graph.py
index 9753741c61..1f0390dae9 100644
--- a/lib/spack/spack/graph.py
+++ b/lib/spack/spack/graph.py
@@ -90,7 +90,7 @@ def topological_sort(spec, reverse=False, deptype=None):
 
     # Work on a copy so this is nondestructive.
     spec = spec.copy(deps=deptype)
-    nodes = spec.index()
+    nodes = spec.index(deptype=deptype)
 
     topo_order = []
     par = dict((name, parents(nodes[name])) for name in nodes.keys())
diff --git a/lib/spack/spack/spec.py b/lib/spack/spack/spec.py
index 5eed6c71c6..5291a7c9d0 100644
--- a/lib/spack/spack/spec.py
+++ b/lib/spack/spack/spec.py
@@ -560,43 +560,47 @@ class CompilerSpec(object):
 
 @key_ordering
 class DependencySpec(object):
-    """Dependencies can be one (or more) of several types:
+    """DependencySpecs connect two nodes in the DAG, and contain deptypes.
+
+    Dependencies can be one (or more) of several types:
 
     - build: needs to be in the PATH at build time.
     - link: is linked to and added to compiler flags.
     - run: needs to be in the PATH for the package to run.
 
     Fields:
-    - spec: the spack.spec.Spec description of a dependency.
-    - deptypes: strings representing the type of dependency this is.
+    - spec: Spec depended on by parent.
+    - parent: Spec that depends on `spec`.
+    - deptypes: list of strings, representing dependency relationships.
     """
 
-    def __init__(self, spec, deptypes, default_deptypes=False):
+    def __init__(self, parent, spec, deptypes):
+        self.parent = parent
         self.spec = spec
-        self.deptypes = deptypes
-        self.default_deptypes = default_deptypes
+        self.deptypes = tuple(sorted(set(deptypes)))
 
     def update_deptypes(self, deptypes):
-        if self.default_deptypes:
-            self.deptypes = deptypes
-            self.default_deptypes = False
-            return True
-        return False
-
-    def _cmp_key(self):
-        return self.spec
+        deptypes = tuple(sorted(set(deptypes)))
+        changed = self.deptypes != deptypes
+        self.deptypes = deptypes
+        return changed
 
     def copy(self):
-        return DependencySpec(self.spec.copy(), self.deptype,
-                              self.default_deptypes)
+        return DependencySpec(self.parent, self.spec, self.deptypes)
+
+    def _cmp_key(self):
+        return (self.parent.name if self.parent else None,
+                self.spec.name if self.spec else None,
+                self.deptypes)
 
     def __str__(self):
-        return str(self.spec)
+        return "%s %s--> %s" % (self.parent.name if self.parent else None,
+                                self.deptypes,
+                                self.spec.name if self.spec else None)
 
 
 @key_ordering
 class VariantSpec(object):
-
     """Variants are named, build-time options for a package.  Names depend
        on the particular package being built, and each named variant can
        be enabled or disabled.
@@ -742,11 +746,11 @@ class DependencyMap(HashableMap):
        The DependencyMap is keyed by name. """
     @property
     def concrete(self):
-        return all(d.spec.concrete for d in self.values())
+        return all((d.spec.concrete and d.deptypes)
+                   for d in self.values())
 
     def __str__(self):
-        return ''.join(
-            ["^" + self[name].format() for name in sorted(self.keys())])
+        return "{deps: %s}" % ', '.join(str(d) for d in sorted(self.values()))
 
 
 @key_ordering
@@ -801,10 +805,21 @@ class Spec(object):
         # This allows users to construct a spec DAG with literals.
         # Note that given two specs a and b, Spec(a) copies a, but
         # Spec(a, b) will copy a but just add b as a dep.
+        deptypes = ()
         for dep in dep_like:
+            if isinstance(dep, Spec):
+                spec = dep
+            elif isinstance(dep, (list, tuple)):
+                # Literals can be deptypes -- if there are tuples in the
+                # list, they will be used as deptypes for the following Spec.
+                deptypes = tuple(dep)
+                continue
+            else:
+                spec = Spec(dep)
+
             spec = dep if isinstance(dep, Spec) else Spec(dep)
-            self._add_dependency(
-                spec, ('build', 'link'), default_deptypes=True)
+            self._add_dependency(spec, deptypes)
+            deptypes = ()
 
     def __getattr__(self, item):
         """Delegate to self.package if the attribute is not in the spec"""
@@ -812,7 +827,7 @@ class Spec(object):
         # not present among self attributes
         if item.endswith('libs'):
             return getattr(self.package, item)
-        raise AttributeError()
+        raise AttributeError(item)
 
     def get_dependency(self, name):
         dep = self._dependencies.get(name)
@@ -824,28 +839,25 @@ class Spec(object):
     def _find_deps(self, where, deptype):
         deptype = canonical_deptype(deptype)
 
-        return [dep.spec
-                for dep in where.values()
-                if deptype and any(d in deptype for d in dep.deptypes)]
+        return [dep for dep in where.values()
+                if deptype and (not dep.deptypes or
+                                any(d in deptype for d in dep.deptypes))]
 
     def dependencies(self, deptype=None):
-        return self._find_deps(self._dependencies, deptype)
+        return [d.spec
+                for d in self._find_deps(self._dependencies, deptype)]
 
     def dependents(self, deptype=None):
-        return self._find_deps(self._dependents, deptype)
-
-    def _find_deps_dict(self, where, deptype):
-        deptype = canonical_deptype(deptype)
-
-        return dict((dep.spec.name, dep)
-                    for dep in where.values()
-                    if deptype and any(d in deptype for d in dep.deptypes))
+        return [d.parent
+                for d in self._find_deps(self._dependents, deptype)]
 
     def dependencies_dict(self, deptype=None):
-        return self._find_deps_dict(self._dependencies, deptype)
+        return dict((d.spec.name, d)
+                    for d in self._find_deps(self._dependencies, deptype))
 
     def dependents_dict(self, deptype=None):
-        return self._find_deps_dict(self._dependents, deptype)
+        return dict((d.parent.name, d)
+                    for d in self._find_deps(self._dependents, deptype))
 
     #
     # Private routines here are called by the parser when building a spec.
@@ -914,15 +926,16 @@ class Spec(object):
                 "Spec for '%s' cannot have two compilers." % self.name)
         self.compiler = compiler
 
-    def _add_dependency(self, spec, deptypes, default_deptypes=False):
+    def _add_dependency(self, spec, deptypes):
         """Called by the parser to add another spec as a dependency."""
         if spec.name in self._dependencies:
             raise DuplicateDependencyError(
                 "Cannot depend on '%s' twice" % spec)
-        self._dependencies[spec.name] = DependencySpec(
-            spec, deptypes, default_deptypes)
-        spec._dependents[self.name] = DependencySpec(
-            self, deptypes, default_deptypes)
+
+        # create an edge and add to parent and child
+        dspec = DependencySpec(self, spec, deptypes)
+        self._dependencies[spec.name] = dspec
+        spec._dependents[self.name] = dspec
 
     #
     # Public interface
@@ -947,8 +960,8 @@ class Spec(object):
         # lead to the same place.  Spack shouldn't deal with any DAGs
         # with multiple roots, so something's wrong if we find one.
         depiter = iter(self._dependents.values())
-        first_root = next(depiter).spec.root
-        assert(all(first_root is d.spec.root for d in depiter))
+        first_root = next(depiter).parent.root
+        assert(all(first_root is d.parent.root for d in depiter))
         return first_root
 
     @property
@@ -998,18 +1011,23 @@ class Spec(object):
                               self._dependencies.concrete)
         return self._concrete
 
-    def traverse(self, visited=None, deptype=None, **kwargs):
-        traversal = self.traverse_with_deptype(visited=visited,
-                                               deptype=deptype,
-                                               **kwargs)
-        if kwargs.get('depth', False):
-            return [(s[0], s[1].spec) for s in traversal]
+    def traverse(self, **kwargs):
+        direction = kwargs.get('direction', 'children')
+        depth = kwargs.get('depth', False)
+
+        get_spec = lambda s: s.spec
+        if direction == 'parents':
+            get_spec = lambda s: s.parent
+
+        if depth:
+            for d, dspec in self.traverse_edges(**kwargs):
+                yield d, get_spec(dspec)
         else:
-            return [s.spec for s in traversal]
+            for dspec in self.traverse_edges(**kwargs):
+                yield get_spec(dspec)
 
-    def traverse_with_deptype(self, visited=None, d=0, deptype=None,
-                              deptype_query=None, _self_deptype=None,
-                              _self_default_deptypes=False, **kwargs):
+    def traverse_edges(self, visited=None, d=0, deptype=None,
+                       deptype_query=None, dep_spec=None, **kwargs):
         """Generic traversal of the DAG represented by this spec.
            This will yield each node in the spec.  Options:
 
@@ -1061,9 +1079,7 @@ class Spec(object):
         direction = kwargs.get('direction', 'children')
         order = kwargs.get('order', 'pre')
 
-        if deptype is None:
-            deptype = alldeps
-
+        deptype = canonical_deptype(deptype)
         if deptype_query is None:
             deptype_query = ('link', 'run')
 
@@ -1084,42 +1100,49 @@ class Spec(object):
         if key in visited and cover == 'nodes':
             return
 
-        def return_val(res):
-            return (d, res) if depth else res
+        def return_val(dspec):
+            if not dspec:
+                # make a fake dspec for the root.
+                if direction == 'parents':
+                    dspec = DependencySpec(self, None, ())
+                else:
+                    dspec = DependencySpec(None, self, ())
+            return (d, dspec) if depth else dspec
 
         yield_me = yield_root or d > 0
 
         # Preorder traversal yields before successors
         if yield_me and order == 'pre':
-            yield return_val(
-                DependencySpec(self, _self_deptype, _self_default_deptypes))
-
-        deps = self.dependencies_dict(deptype)
+            yield return_val(dep_spec)
 
         # Edge traversal yields but skips children of visited nodes
         if not (key in visited and cover == 'edges'):
             # This code determines direction and yields the children/parents
-
-            successors = deps
-            if direction == 'parents':
-                successors = self.dependents_dict()  # TODO: deptype?
+            if direction == 'children':
+                successors = self.dependencies_dict(deptype)
+                succ = lambda s: s.spec
+            elif direction == 'parents':
+                successors = self.dependents_dict(deptype)
+                succ = lambda s: s.parent
+            else:
+                raise ValueError('Invalid traversal direction: %s' % direction)
 
             visited.add(key)
-            for name in sorted(successors):
+            for name, dspec in sorted(successors.items()):
                 child = successors[name]
-                children = child.spec.traverse_with_deptype(
-                    visited, d=d + 1, deptype=deptype,
+                children = succ(child).traverse_edges(
+                    visited,
+                    d=(d + 1),
+                    deptype=deptype,
                     deptype_query=deptype_query,
-                    _self_deptype=child.deptypes,
-                    _self_default_deptypes=child.default_deptypes,
+                    dep_spec=dspec,
                     **kwargs)
                 for elt in children:
                     yield elt
 
         # Postorder traversal yields after successors
         if yield_me and order == 'post':
-            yield return_val(
-                DependencySpec(self, _self_deptype, _self_default_deptypes))
+            yield return_val(dep_spec)
 
     @property
     def short_spec(self):
@@ -1293,7 +1316,7 @@ class Spec(object):
             for dname, dhash, dtypes in Spec.read_yaml_dep_specs(yaml_deps):
                 # Fill in dependencies by looking them up by name in deps dict
                 deps[name]._dependencies[dname] = DependencySpec(
-                    deps[dname], set(dtypes))
+                    deps[name], deps[dname], dtypes)
 
         return spec
 
@@ -1367,7 +1390,7 @@ class Spec(object):
         """Replace this virtual spec with a concrete spec."""
         assert(self.virtual)
         for name, dep_spec in self._dependents.items():
-            dependent = dep_spec.spec
+            dependent = dep_spec.parent
             deptypes = dep_spec.deptypes
 
             # remove self from all dependents.
@@ -1375,8 +1398,7 @@ class Spec(object):
 
             # add the replacement, unless it is already a dep of dependent.
             if concrete.name not in dependent._dependencies:
-                dependent._add_dependency(concrete, deptypes,
-                                          dep_spec.default_deptypes)
+                dependent._add_dependency(concrete, deptypes)
 
     def _expand_virtual_packages(self):
         """Find virtual packages in this spec, replace them with providers,
@@ -1550,13 +1572,6 @@ class Spec(object):
         return clone
 
     def flat_dependencies(self, **kwargs):
-        flat_deps = DependencyMap()
-        flat_deps_deptypes = self.flat_dependencies_with_deptype(**kwargs)
-        for name, depspec in flat_deps_deptypes.items():
-            flat_deps[name] = depspec.spec
-        return flat_deps
-
-    def flat_dependencies_with_deptype(self, **kwargs):
         """Return a DependencyMap containing all of this spec's
            dependencies with their constraints merged.
 
@@ -1569,30 +1584,22 @@ class Spec(object):
         copy = kwargs.get('copy', True)
         deptype_query = kwargs.get('deptype_query')
 
-        flat_deps = DependencyMap()
+        flat_deps = {}
         try:
-            deptree = self.traverse_with_deptype(root=False,
-                                                 deptype_query=deptype_query)
-            for depspec in deptree:
-                spec = depspec.spec
-                deptypes = depspec.deptypes
+            deptree = self.traverse(root=False, deptype_query=deptype_query)
+            for spec in deptree:
 
                 if spec.name not in flat_deps:
                     if copy:
-                        dep_spec = DependencySpec(spec.copy(deps=False),
-                                                  deptypes,
-                                                  depspec.default_deptypes)
-                    else:
-                        dep_spec = DependencySpec(
-                            spec, deptypes, depspec.default_deptypes)
-                    flat_deps[spec.name] = dep_spec
+                        spec = spec.copy(deps=False)
+                    flat_deps[spec.name] = spec
                 else:
-                    flat_deps[spec.name].spec.constrain(spec)
+                    flat_deps[spec.name].constrain(spec)
 
             if not copy:
-                for depspec in flat_deps.values():
-                    depspec.spec._dependencies.clear()
-                    depspec.spec._dependents.clear()
+                for spec in flat_deps.values():
+                    spec._dependencies.clear()
+                    spec._dependents.clear()
                 self._dependencies.clear()
 
             return flat_deps
@@ -1696,9 +1703,7 @@ class Spec(object):
                 dep = provider
         else:
             index = ProviderIndex([dep], restrict=True)
-            for vspec in (v.spec
-                          for v in spec_deps.values()
-                          if v.spec.virtual):
+            for vspec in (v for v in spec_deps.values() if v.virtual):
                 if index.providers_for(vspec):
                     vspec._replace_with(dep)
                     del spec_deps[vspec.name]
@@ -1708,35 +1713,37 @@ class Spec(object):
                     if required:
                         raise UnsatisfiableProviderSpecError(required[0], dep)
             provider_index.update(dep)
+
         # If the spec isn't already in the set of dependencies, clone
         # it from the package description.
         if dep.name not in spec_deps:
-            spec_deps[dep.name] = DependencySpec(dep.copy(), deptypes)
+            spec_deps[dep.name] = dep.copy()
             changed = True
         else:
-            changed = spec_deps[dep.name].update_deptypes(deptypes)
-            if changed and dep.name in self._dependencies:
-                child_spec = self._dependencies[dep.name].spec
-                child_spec._dependents[self.name].update_deptypes(deptypes)
+            dspec = spec_deps[dep.name]
+            if self.name not in dspec._dependents:
+                self._add_dependency(dspec, deptypes)
+            else:
+                dependent = dspec._dependents[self.name]
+                changed = dependent.update_deptypes(deptypes)
+
         # Constrain package information with spec info
         try:
-            changed |= spec_deps[dep.name].spec.constrain(dep)
+            changed |= spec_deps[dep.name].constrain(dep)
 
         except UnsatisfiableSpecError as e:
             e.message = "Invalid spec: '%s'. "
             e.message += "Package %s requires %s %s, but spec asked for %s"
-            e.message %= (spec_deps[dep.name].spec, dep.name,
+            e.message %= (spec_deps[dep.name], dep.name,
                           e.constraint_type, e.required, e.provided)
             raise e
 
         # Add merged spec to my deps and recurse
         dependency = spec_deps[dep.name]
         if dep.name not in self._dependencies:
-            self._add_dependency(
-                dependency.spec, dependency.deptypes,
-                dependency.default_deptypes)
+            self._add_dependency(dependency, deptypes)
 
-        changed |= dependency.spec._normalize_helper(
+        changed |= dependency._normalize_helper(
             visited, spec_deps, provider_index)
         return changed
 
@@ -1801,17 +1808,17 @@ class Spec(object):
         # Ensure first that all packages & compilers in the DAG exist.
         self.validate_names()
         # Get all the dependencies into one DependencyMap
-        spec_deps = self.flat_dependencies_with_deptype(
-            copy=False, deptype_query=alldeps)
+        spec_deps = self.flat_dependencies(copy=False, deptype_query=alldeps)
 
         # Initialize index of virtual dependency providers if
         # concretize didn't pass us one already
         provider_index = ProviderIndex(
-            [s.spec for s in spec_deps.values()], restrict=True)
+            [s for s in spec_deps.values()], restrict=True)
 
         # traverse the package DAG and fill out dependencies according
         # to package files & their 'when' specs
         visited = set()
+
         any_change = self._normalize_helper(visited, spec_deps, provider_index)
 
         # If there are deps specified but not visited, they're not
@@ -1945,8 +1952,7 @@ class Spec(object):
             dep_spec_copy = other.get_dependency(name)
             dep_copy = dep_spec_copy.spec
             deptypes = dep_spec_copy.deptypes
-            self._add_dependency(dep_copy.copy(), deptypes,
-                                 dep_spec_copy.default_deptypes)
+            self._add_dependency(dep_copy.copy(), deptypes)
             changed = True
 
         return changed
@@ -2168,30 +2174,13 @@ class Spec(object):
 
         # If we copy dependencies, preserve DAG structure in the new spec
         if deps:
-            # This copies the deps from other using _dup(deps=False)
-            deptypes = alldeps
+            deptypes = alldeps  # by default copy all deptypes
+
+            # if caller restricted deptypes to be copied, adjust that here.
             if isinstance(deps, (tuple, list)):
                 deptypes = deps
-            new_nodes = other.flat_dependencies(deptypes=deptypes)
-            new_nodes[self.name] = self
-
-            stack = [other]
-            while stack:
-                cur_spec = stack.pop(0)
-                new_spec = new_nodes[cur_spec.name]
-
-                for depspec in cur_spec._dependencies.values():
-                    if not any(d in deptypes for d in depspec.deptypes):
-                        continue
 
-                    stack.append(depspec.spec)
-
-                    # XXX(deptype): add any new deptypes that may have appeared
-                    #               here.
-                    if depspec.spec.name not in new_spec._dependencies:
-                        new_spec._add_dependency(
-                            new_nodes[depspec.spec.name], depspec.deptypes,
-                            depspec.default_deptypes)
+            self._dup_deps(other, deptypes)
 
         # These fields are all cached results of expensive operations.
         # If we preserved the original structure, we can copy them
@@ -2209,6 +2198,21 @@ class Spec(object):
 
         return changed
 
+    def _dup_deps(self, other, deptypes):
+        new_specs = {self.name: self}
+        for dspec in other.traverse_edges(cover='edges', root=False):
+            if (dspec.deptypes and
+                not any(d in deptypes for d in dspec.deptypes)):
+                continue
+
+            if dspec.parent.name not in new_specs:
+                new_specs[dspec.parent.name] = dspec.parent.copy(deps=False)
+            if dspec.spec.name not in new_specs:
+                new_specs[dspec.spec.name] = dspec.spec.copy(deps=False)
+
+            new_specs[dspec.parent.name]._add_dependency(
+                new_specs[dspec.spec.name], dspec.deptypes)
+
     def copy(self, deps=True):
         """Return a copy of this spec.
 
@@ -2267,7 +2271,7 @@ class Spec(object):
         deps = self.flat_dependencies()
         return tuple(deps[name] for name in sorted(deps))
 
-    def _eq_dag(self, other, vs, vo):
+    def _eq_dag(self, other, vs, vo, deptypes):
         """Recursive helper for eq_dag and ne_dag.  Does the actual DAG
            traversal."""
         vs.add(id(self))
@@ -2279,12 +2283,16 @@ class Spec(object):
         if len(self._dependencies) != len(other._dependencies):
             return False
 
-        ssorted = [self._dependencies[name].spec
+        ssorted = [self._dependencies[name]
                    for name in sorted(self._dependencies)]
-        osorted = [other._dependencies[name].spec
+        osorted = [other._dependencies[name]
                    for name in sorted(other._dependencies)]
 
-        for s, o in zip(ssorted, osorted):
+        for s_dspec, o_dspec in zip(ssorted, osorted):
+            if deptypes and s_dspec.deptypes != o_dspec.deptypes:
+                return False
+
+            s, o = s_dspec.spec, o_dspec.spec
             visited_s = id(s) in vs
             visited_o = id(o) in vo
 
@@ -2297,18 +2305,18 @@ class Spec(object):
                 continue
 
             # Recursive check for equality
-            if not s._eq_dag(o, vs, vo):
+            if not s._eq_dag(o, vs, vo, deptypes):
                 return False
 
         return True
 
-    def eq_dag(self, other):
-        """True if the full dependency DAGs of specs are equal"""
-        return self._eq_dag(other, set(), set())
+    def eq_dag(self, other, deptypes=True):
+        """True if the full dependency DAGs of specs are equal."""
+        return self._eq_dag(other, set(), set(), deptypes)
 
-    def ne_dag(self, other):
-        """True if the full dependency DAGs of specs are not equal"""
-        return not self.eq_dag(other)
+    def ne_dag(self, other, deptypes=True):
+        """True if the full dependency DAGs of specs are not equal."""
+        return not self.eq_dag(other, set(), set(), deptypes)
 
     def _cmp_node(self):
         """Comparison key for just *this node* and not its deps."""
@@ -2600,7 +2608,7 @@ class Spec(object):
         check_kwargs(kwargs, self.tree)
 
         out = ""
-        for d, dep_spec in self.traverse_with_deptype(
+        for d, dep_spec in self.traverse_edges(
                 order='pre', cover=cover, depth=True, deptypes=deptypes):
             node = dep_spec.spec
 
@@ -2716,9 +2724,10 @@ class SpecParser(spack.parse.Parser):
                     else:
                         self.expect(ID)
                         dep = self.spec(self.token.value)
-                    def_deptypes = ('build', 'link')
-                    specs[-1]._add_dependency(
-                        dep, def_deptypes, default_deptypes=True)
+
+                    # command line deps get empty deptypes now.
+                    # Real deptypes are assigned later per packages.
+                    specs[-1]._add_dependency(dep, ())
 
                 else:
                     # Attempt to construct an anonymous spec, but check that
diff --git a/lib/spack/spack/test/cmd/install.py b/lib/spack/spack/test/cmd/install.py
index 591bf02340..304eb04a55 100644
--- a/lib/spack/spack/test/cmd/install.py
+++ b/lib/spack/spack/test/cmd/install.py
@@ -124,9 +124,11 @@ class MockPackageDb(object):
 def mock_fetch_log(path):
     return []
 
+
 specX = MockSpec('X', '1.2.0')
 specY = MockSpec('Y', '2.3.8')
-specX._dependencies['Y'] = spack.DependencySpec(specY, spack.alldeps)
+specX._dependencies['Y'] = spack.spec.DependencySpec(
+    specX, specY, spack.alldeps)
 pkgX = MockPackage(specX, 'logX')
 pkgY = MockPackage(specY, 'logY')
 specX.package = pkgX
diff --git a/lib/spack/spack/test/optional_deps.py b/lib/spack/spack/test/optional_deps.py
index f013817b6f..d2b8c3e3ac 100644
--- a/lib/spack/spack/test/optional_deps.py
+++ b/lib/spack/spack/test/optional_deps.py
@@ -94,8 +94,7 @@ def test_normalize(spec_and_expected, config, builtin_mock):
     spec, expected = spec_and_expected
     spec = Spec(spec)
     spec.normalize()
-    assert spec == expected
-    assert spec.eq_dag(expected)
+    assert spec.eq_dag(expected, deptypes=False)
 
 
 def test_default_variant(config, builtin_mock):
diff --git a/lib/spack/spack/test/spec_dag.py b/lib/spack/spack/test/spec_dag.py
index e1d3f24e07..1578bcacbe 100644
--- a/lib/spack/spack/test/spec_dag.py
+++ b/lib/spack/spack/test/spec_dag.py
@@ -373,11 +373,12 @@ class TestSpecDag(object):
         assert spec != expected_flat
         assert not spec.eq_dag(expected_flat)
 
-        assert spec == expected_normalized
-        assert spec.eq_dag(expected_normalized)
+        # verify DAG structure without deptypes.
+        assert spec.eq_dag(expected_normalized, deptypes=False)
+        assert not spec.eq_dag(non_unique_nodes, deptypes=False)
 
-        assert spec == non_unique_nodes
-        assert not spec.eq_dag(non_unique_nodes)
+        assert not spec.eq_dag(expected_normalized, deptypes=True)
+        assert not spec.eq_dag(non_unique_nodes, deptypes=True)
 
     def test_normalize_with_virtual_package(self):
         spec = Spec('mpileaks ^mpi ^libelf@1.8.11 ^libdwarf')
@@ -552,3 +553,140 @@ class TestSpecDag(object):
 
             with pytest.raises(ValueError):
                 spack.spec.base32_prefix_bits(test_hash, 256)
+
+    def test_traversal_directions(self):
+        """Make sure child and parent traversals of specs work."""
+        # We'll use d for a diamond dependency
+        d = Spec('d')
+
+        # Mock spec.
+        spec = Spec('a',
+                    Spec('b',
+                         Spec('c', d),
+                         Spec('e')),
+                    Spec('f',
+                         Spec('g', d)))
+
+        assert (
+            ['a', 'b', 'c', 'd', 'e', 'f', 'g'] ==
+            [s.name for s in spec.traverse(direction='children')])
+
+        assert (
+            ['g', 'f', 'a'] ==
+            [s.name for s in spec['g'].traverse(direction='parents')])
+
+        assert (
+            ['d', 'c', 'b', 'a', 'g', 'f'] ==
+            [s.name for s in spec['d'].traverse(direction='parents')])
+
+    def test_edge_traversals(self):
+        """Make sure child and parent traversals of specs work."""
+        # We'll use d for a diamond dependency
+        d = Spec('d')
+
+        # Mock spec.
+        spec = Spec('a',
+                    Spec('b',
+                         Spec('c', d),
+                         Spec('e')),
+                    Spec('f',
+                         Spec('g', d)))
+
+        assert (
+            ['a', 'b', 'c', 'd', 'e', 'f', 'g'] ==
+            [s.name for s in spec.traverse(direction='children')])
+
+        assert (
+            ['g', 'f', 'a'] ==
+            [s.name for s in spec['g'].traverse(direction='parents')])
+
+        assert (
+            ['d', 'c', 'b', 'a', 'g', 'f'] ==
+            [s.name for s in spec['d'].traverse(direction='parents')])
+
+    def test_copy_dependencies(self):
+        s1 = Spec('mpileaks ^mpich2@1.1')
+        s2 = s1.copy()
+
+        assert '^mpich2@1.1' in s2
+        assert '^mpich2' in s2
+
+    def test_construct_spec_with_deptypes(self):
+        s = Spec('a',
+                 Spec('b',
+                      ['build'], Spec('c')),
+                 Spec('d',
+                      ['build', 'link'], Spec('e',
+                                              ['run'], Spec('f'))))
+
+        assert s['b']._dependencies['c'].deptypes == ('build',)
+        assert s['d']._dependencies['e'].deptypes == ('build', 'link')
+        assert s['e']._dependencies['f'].deptypes == ('run',)
+
+        assert s['b']._dependencies['c'].deptypes == ('build',)
+        assert s['d']._dependencies['e'].deptypes == ('build', 'link')
+        assert s['e']._dependencies['f'].deptypes == ('run',)
+
+        assert s['c']._dependents['b'].deptypes == ('build',)
+        assert s['e']._dependents['d'].deptypes == ('build', 'link')
+        assert s['f']._dependents['e'].deptypes == ('run',)
+
+        assert s['c']._dependents['b'].deptypes == ('build',)
+        assert s['e']._dependents['d'].deptypes == ('build', 'link')
+        assert s['f']._dependents['e'].deptypes == ('run',)
+
+    def check_diamond_deptypes(self, spec):
+        """Validate deptypes in dt-diamond spec."""
+        assert spec['dt-diamond']._dependencies[
+            'dt-diamond-left'].deptypes == ('build', 'link')
+
+        assert spec['dt-diamond']._dependencies[
+            'dt-diamond-right'].deptypes == ('build', 'link')
+
+        assert spec['dt-diamond-left']._dependencies[
+            'dt-diamond-bottom'].deptypes == ('build',)
+
+        assert spec['dt-diamond-right'] ._dependencies[
+            'dt-diamond-bottom'].deptypes == ('build', 'link', 'run')
+
+    def check_diamond_normalized_dag(self, spec):
+        bottom = Spec('dt-diamond-bottom')
+        dag = Spec('dt-diamond',
+                   ['build', 'link'], Spec('dt-diamond-left',
+                                           ['build'], bottom),
+                   ['build', 'link'], Spec('dt-diamond-right',
+                                           ['build', 'link', 'run'], bottom))
+        assert spec.eq_dag(dag)
+
+    def test_normalize_diamond_deptypes(self):
+        """Ensure that dependency types are preserved even if the same thing is
+           depended on in two different ways."""
+        s = Spec('dt-diamond')
+        s.normalize()
+
+        self.check_diamond_deptypes(s)
+        self.check_diamond_normalized_dag(s)
+
+    def test_concretize_deptypes(self):
+        """Ensure that dependency types are preserved after concretization."""
+        s = Spec('dt-diamond')
+        s.concretize()
+        self.check_diamond_deptypes(s)
+
+    def test_copy_deptypes(self):
+        """Ensure that dependency types are preserved by spec copy."""
+        s1 = Spec('dt-diamond')
+        s1.normalize()
+        self.check_diamond_deptypes(s1)
+        self.check_diamond_normalized_dag(s1)
+
+        s2 = s1.copy()
+        self.check_diamond_normalized_dag(s2)
+        self.check_diamond_deptypes(s2)
+
+        s3 = Spec('dt-diamond')
+        s3.concretize()
+        self.check_diamond_deptypes(s3)
+
+        s4 = s3.copy()
+        self.check_diamond_deptypes(s4)