Merge remote-tracking branch 'upstream/develop' into pkg-numdiff

12 files changed, 311 insertions, 211 deletions

diff --git a/lib/spack/env/cc b/lib/spack/env/cc
index 4a3e6eddc9..2eb6f46afe 100755
--- a/lib/spack/env/cc
+++ b/lib/spack/env/cc
@@ -65,7 +65,7 @@ function die {
 }
 
 for param in $parameters; do
-    if [ -z "${!param}" ]; then
+    if [[ -z ${!param} ]]; then
         die "Spack compiler must be run from spack!  Input $param was missing!"
     fi
 done
@@ -78,12 +78,17 @@ done
 # 'command' is set based on the input command to $SPACK_[CC|CXX|F77|F90]
 #
 # 'mode' is set to one of:
+#    cpp     preprocess
 #    cc      compile
+#    as      assemble
 #    ld      link
 #    ccld    compile & link
-#    cpp     preprocessor
 #    vcheck  version check
 #
+# Depending on the mode, we may or may not add extra rpaths.
+# This variable controls whether they are added.
+add_rpaths=true
+
 command=$(basename "$0")
 case "$command" in
     cc|c89|c99|gcc|clang|icc|pgcc|xlc)
@@ -107,13 +112,26 @@ case "$command" in
         ;;
     ld)
         mode=ld
+
+        # Darwin's linker has a -r argument that merges object files
+        # together. It doesn't work with -rpath.
+        if [[ $OSTYPE = darwin* ]]; then
+            for arg in "$@"; do
+                if [ "$arg" = -r ]; then
+                    add_rpaths=false
+                    break
+	            fi
+            done
+        fi
         ;;
     *)
         die "Unkown compiler: $command"
         ;;
 esac
 
-# If any of the arguments below is present then the mode is vcheck. In vcheck mode nothing is added in terms of extra search paths or libraries
+# If any of the arguments below is present then the mode is vcheck. In
+# vcheck mode nothing is added in terms of extra search paths or
+# libraries
 if [ -z "$mode" ]; then
     for arg in "$@"; do
         if [ "$arg" = -v -o "$arg" = -V -o "$arg" = --version -o "$arg" = -dumpversion ]; then
@@ -124,13 +142,15 @@ if [ -z "$mode" ]; then
 fi
 
 # Finish setting up the mode.
-
 if [ -z "$mode" ]; then
     mode=ccld
     for arg in "$@"; do
         if [ "$arg" = -E ]; then
             mode=cpp
             break
+        elif [ "$arg" = -S ]; then
+            mode=as
+            break
         elif [ "$arg" = -c ]; then
             mode=cc
             break
@@ -146,168 +166,56 @@ fi
 
 # Check that at least one of the real commands was actually selected,
 # otherwise we don't know what to execute.
-if [ -z "$command" ]; then
+if [[ -z $command ]]; then
     die "ERROR: Compiler '$SPACK_COMPILER_SPEC' does not support compiling $language programs."
 fi
 
-# Save original command for debug logging
-input_command="$@"
-
 if [ "$mode" == vcheck ] ; then
     exec ${command} "$@"
 fi
 
-#
-# Now do real parsing of the command line args, trying hard to keep
-# non-rpath linker arguments in the proper order w.r.t. other command
-# line arguments.  This is important for things like groups.
-#
-includes=()
-libraries=()
-libs=()
-rpaths=()
-other_args=()
-
-while [ -n "$1" ]; do
-    case "$1" in
-        -I*)
-            arg="${1#-I}"
-            if [ -z "$arg" ]; then shift; arg="$1"; fi
-            includes+=("$arg")
-            ;;
-        -L*)
-            arg="${1#-L}"
-            if [ -z "$arg" ]; then shift; arg="$1"; fi
-            libraries+=("$arg")
-            ;;
-        -l*)
-            arg="${1#-l}"
-            if [ -z "$arg" ]; then shift; arg="$1"; fi
-            libs+=("$arg")
-            ;;
-        -Wl,*)
-            arg="${1#-Wl,}"
-            # TODO: Handle multiple -Wl, continuations of -Wl,-rpath
-            if [[ $arg == -rpath=* ]]; then
-                arg="${arg#-rpath=}"
-                for rpath in ${arg//,/ }; do
-                    rpaths+=("$rpath")
-                done
-            elif [[ $arg == -rpath,* ]]; then
-                arg="${arg#-rpath,}"
-                for rpath in ${arg//,/ }; do
-                    rpaths+=("$rpath")
-                done
-            elif [[ $arg == -rpath ]]; then
-                shift; arg="$1"
-                if [[ $arg != '-Wl,'* ]]; then
-                    die "-Wl,-rpath was not followed by -Wl,*"
-                fi
-                arg="${arg#-Wl,}"
-                for rpath in ${arg//,/ }; do
-                    rpaths+=("$rpath")
-                done
-            else
-                other_args+=("-Wl,$arg")
-            fi
-            ;;
-        -Xlinker)
-            shift; arg="$1";
-            if [[ $arg = -rpath=* ]]; then
-                rpaths+=("${arg#-rpath=}")
-            elif [[ $arg = -rpath ]]; then
-                shift; arg="$1"
-                if [[ $arg != -Xlinker ]]; then
-                    die "-Xlinker -rpath was not followed by -Xlinker <arg>"
-                fi
-                shift; arg="$1"
-                rpaths+=("$arg")
-            else
-                other_args+=("-Xlinker")
-                other_args+=("$arg")
-            fi
-            ;;
-        *)
-            other_args+=("$1")
-            ;;
-    esac
-    shift
-done
-
-# Dump parsed values for unit testing if asked for
-if [ -n "$SPACK_TEST_COMMAND" ]; then
-    IFS=$'\n'
-    case "$SPACK_TEST_COMMAND" in
-        dump-includes)   echo "${includes[*]}";;
-        dump-libraries)  echo "${libraries[*]}";;
-        dump-libs)       echo "${libs[*]}";;
-        dump-rpaths)     echo "${rpaths[*]}";;
-        dump-other-args) echo "${other_args[*]}";;
-        dump-all)
-            echo "INCLUDES:"
-            echo "${includes[*]}"
-            echo
-            echo "LIBRARIES:"
-            echo "${libraries[*]}"
-            echo
-            echo "LIBS:"
-            echo "${libs[*]}"
-            echo
-            echo "RPATHS:"
-            echo "${rpaths[*]}"
-            echo
-            echo "ARGS:"
-            echo "${other_args[*]}"
-            ;;
-        *)
-            echo "ERROR: Unknown test command"
-            exit 1 ;;
-    esac
-    exit
-fi
+# Save original command for debug logging
+input_command="$@"
+args=("$@")
 
 # Read spack dependencies from the path environment variable
 IFS=':' read -ra deps <<< "$SPACK_DEPENDENCIES"
 for dep in "${deps[@]}"; do
-    if [ -d "$dep/include" ]; then
-        includes+=("$dep/include")
+    # Prepend include directories
+    if [[ -d $dep/include ]]; then
+        if [[ $mode = cpp || $mode = cc || $mode = as || $mode = ccld ]]; then
+            args=("-I$dep/include" "${args[@]}")
+        fi
     fi
 
-    if [ -d "$dep/lib" ]; then
-        libraries+=("$dep/lib")
-        rpaths+=("$dep/lib")
+    # Prepend lib and RPATH directories
+    if [[ -d $dep/lib ]]; then
+        if [[ $mode = ccld ]]; then
+            $add_rpaths && args=("-Wl,-rpath,$dep/lib" "${args[@]}")
+            args=("-L$dep/lib" "${args[@]}")
+        elif [[ $mode = ld ]]; then
+            $add_rpaths && args=("-rpath" "$dep/lib" "${args[@]}")
+            args=("-L$dep/lib" "${args[@]}")
+        fi
     fi
 
-    if [ -d "$dep/lib64" ]; then
-        libraries+=("$dep/lib64")
-        rpaths+=("$dep/lib64")
+    # Prepend lib64 and RPATH directories
+    if [[ -d $dep/lib64 ]]; then
+        if [[ $mode = ccld ]]; then
+            $add_rpaths && args=("-Wl,-rpath,$dep/lib64" "${args[@]}")
+            args=("-L$dep/lib64" "${args[@]}")
+        elif [[ $mode = ld ]]; then
+            $add_rpaths && args=("-rpath" "$dep/lib64" "${args[@]}")
+            args=("-L$dep/lib64" "${args[@]}")
+        fi
     fi
 done
 
 # Include all -L's and prefix/whatever dirs in rpath
-for dir in "${libraries[@]}"; do
-    [[ dir = $SPACK_INSTALL* ]] && rpaths+=("$dir")
-done
-rpaths+=("$SPACK_PREFIX/lib")
-rpaths+=("$SPACK_PREFIX/lib64")
-
-# Put the arguments together
-args=()
-for dir in "${includes[@]}";  do args+=("-I$dir"); done
-args+=("${other_args[@]}")
-for dir in "${libraries[@]}"; do args+=("-L$dir"); done
-for lib in "${libs[@]}";      do args+=("-l$lib"); done
-
-if [ "$mode" = ccld ]; then
-    for dir in "${rpaths[@]}"; do
-        args+=("-Wl,-rpath")
-        args+=("-Wl,$dir");
-    done
-elif [ "$mode" = ld ]; then
-    for dir in "${rpaths[@]}"; do
-        args+=("-rpath")
-        args+=("$dir");
-    done
+if [[ $mode = ccld ]]; then
+    $add_rpaths && args=("-Wl,-rpath,$SPACK_PREFIX/lib" "-Wl,-rpath,$SPACK_PREFIX/lib64" "${args[@]}")
+elif [[ $mode = ld ]]; then
+    $add_rpaths && args=("-rpath" "$SPACK_PREFIX/lib" "-rpath" "$SPACK_PREFIX/lib64" "${args[@]}")
 fi
 
 #
@@ -323,34 +231,37 @@ unset DYLD_LIBRARY_PATH
 #
 IFS=':' read -ra env_path <<< "$PATH"
 IFS=':' read -ra spack_env_dirs <<< "$SPACK_ENV_PATH"
-spack_env_dirs+=(".")
+spack_env_dirs+=("" ".")
 PATH=""
 for dir in "${env_path[@]}"; do
     remove=""
     for rm_dir in "${spack_env_dirs[@]}"; do
-        if [ "$dir" = "$rm_dir" ]; then remove=True; fi
+        if [[ $dir = $rm_dir ]]; then remove=True; fi
     done
-    if [ -z "$remove" ]; then
-        if [ -z "$PATH" ]; then
-            PATH="$dir"
-        else
-            PATH="$PATH:$dir"
-        fi
+    if [[ -z $remove ]]; then
+        PATH="${PATH:+$PATH:}$dir"
     fi
 done
 export PATH
 
-full_command=("$command")
-full_command+=("${args[@]}")
+full_command=("$command" "${args[@]}")
+
+# In test command mode, write out full command for Spack tests.
+if [[ $SPACK_TEST_COMMAND = dump-args ]]; then
+    echo "${full_command[@]}"
+    exit
+elif [[ -n $SPACK_TEST_COMMAND ]]; then
+    die "ERROR: Unknown test command"
+fi
 
 #
 # Write the input and output commands to debug logs if it's asked for.
 #
-if [ "$SPACK_DEBUG" = "TRUE" ]; then
+if [[ $SPACK_DEBUG = TRUE ]]; then
     input_log="$SPACK_DEBUG_LOG_DIR/spack-cc-$SPACK_SHORT_SPEC.in.log"
     output_log="$SPACK_DEBUG_LOG_DIR/spack-cc-$SPACK_SHORT_SPEC.out.log"
-    echo "$input_command"     >> $input_log
-    echo "$mode       ${full_command[@]}" >> $output_log
+    echo "[$mode] $command $input_command" >> $input_log
+    echo "[$mode] ${full_command[@]}" >> $output_log
 fi
 
 exec "${full_command[@]}"
diff --git a/lib/spack/llnl/util/filesystem.py b/lib/spack/llnl/util/filesystem.py
index c4665c284c..46ca03bec4 100644
--- a/lib/spack/llnl/util/filesystem.py
+++ b/lib/spack/llnl/util/filesystem.py
@@ -27,9 +27,10 @@ __all__ = ['set_install_permissions', 'install', 'install_tree', 'traverse_tree'
            'force_remove', 'join_path', 'ancestor', 'can_access', 'filter_file',
            'FileFilter', 'change_sed_delimiter', 'is_exe', 'force_symlink',
            'set_executable', 'copy_mode', 'unset_executable_mode',
-           'remove_dead_links', 'remove_linked_tree']
+           'remove_dead_links', 'remove_linked_tree', 'fix_darwin_install_name']
 
 import os
+import glob
 import sys
 import re
 import shutil
@@ -38,6 +39,7 @@ import errno
 import getpass
 from contextlib import contextmanager, closing
 from tempfile import NamedTemporaryFile
+import subprocess
 
 import llnl.util.tty as tty
 from spack.util.compression import ALLOWED_ARCHIVE_TYPES
@@ -392,3 +394,29 @@ def remove_linked_tree(path):
             os.unlink(path)
         else:
             shutil.rmtree(path, True)
+
+def fix_darwin_install_name(path):
+    """
+    Fix install name of dynamic libraries on Darwin to have full path.
+    There are two parts of this task:
+    (i) use install_name('-id',...) to change install name of a single lib;
+    (ii) use install_name('-change',...) to change the cross linking between libs.
+    The function assumes that all libraries are in one folder and currently won't
+    follow subfolders.
+
+    Args:
+        path: directory in which .dylib files are alocated
+
+    """
+    libs = glob.glob(join_path(path,"*.dylib"))
+    for lib in libs:
+        # fix install name first:
+        subprocess.Popen(["install_name_tool", "-id",lib,lib], stdout=subprocess.PIPE).communicate()[0]
+        long_deps = subprocess.Popen(["otool", "-L",lib], stdout=subprocess.PIPE).communicate()[0].split('\n')
+        deps = [dep.partition(' ')[0][1::] for dep in long_deps[2:-1]]
+        # fix all dependencies:
+        for dep in deps:
+            for loc in libs:
+                if dep == os.path.basename(loc):
+                    subprocess.Popen(["install_name_tool", "-change",dep,loc,lib], stdout=subprocess.PIPE).communicate()[0]
+                    break
diff --git a/lib/spack/llnl/util/lang.py b/lib/spack/llnl/util/lang.py
index 13d301f84e..3b4e2c8352 100644
--- a/lib/spack/llnl/util/lang.py
+++ b/lib/spack/llnl/util/lang.py
@@ -117,7 +117,8 @@ def caller_locals():
        scope.  Yes, this is some black magic, and yes it's useful
        for implementing things like depends_on and provides.
     """
-    stack = inspect.stack()
+    # Passing zero here skips line context for speed.
+    stack = inspect.stack(0)
     try:
         return stack[2][0].f_locals
     finally:
@@ -128,7 +129,8 @@ def get_calling_module_name():
     """Make sure that the caller is a class definition, and return the
        enclosing module's name.
     """
-    stack = inspect.stack()
+    # Passing zero here skips line context for speed.
+    stack = inspect.stack(0)
     try:
         # Make sure locals contain __module__
         caller_locals = stack[2][0].f_locals
diff --git a/lib/spack/spack/build_environment.py b/lib/spack/spack/build_environment.py
index fc5b7d6207..119a255a34 100644
--- a/lib/spack/spack/build_environment.py
+++ b/lib/spack/spack/build_environment.py
@@ -225,7 +225,7 @@ def set_module_variables_for_package(pkg, module):
     m.spack_cc  = join_path(link_dir, pkg.compiler.link_paths['cc'])
     m.spack_cxx = join_path(link_dir, pkg.compiler.link_paths['cxx'])
     m.spack_f77 = join_path(link_dir, pkg.compiler.link_paths['f77'])
-    m.spack_f90 = join_path(link_dir, pkg.compiler.link_paths['fc'])
+    m.spack_fc  = join_path(link_dir, pkg.compiler.link_paths['fc'])
 
     # Emulate some shell commands for convenience
     m.pwd          = os.getcwd
@@ -270,32 +270,56 @@ def parent_class_modules(cls):
     return result
 
 
+def setup_module_variables_for_dag(pkg):
+    """Set module-scope variables for all packages in the DAG."""
+    for spec in pkg.spec.traverse(order='post'):
+        # If a user makes their own package repo, e.g.
+        # spack.repos.mystuff.libelf.Libelf, and they inherit from
+        # an existing class like spack.repos.original.libelf.Libelf,
+        # then set the module variables for both classes so the
+        # parent class can still use them if it gets called.
+        spkg = spec.package
+        modules = parent_class_modules(spkg.__class__)
+        for mod in modules:
+            set_module_variables_for_package(spkg, mod)
+        set_module_variables_for_package(spkg, spkg.module)
+
+
 def setup_package(pkg):
     """Execute all environment setup routines."""
     spack_env = EnvironmentModifications()
     run_env   = EnvironmentModifications()
 
+    # Before proceeding, ensure that specs and packages are consistent
+    #
+    # This is a confusing behavior due to how packages are
+    # constructed.  `setup_dependent_package` may set attributes on
+    # specs in the DAG for use by other packages' install
+    # method. However, spec.package will look up a package via
+    # spack.repo, which defensively copies specs into packages.  This
+    # code ensures that all packages in the DAG have pieces of the
+    # same spec object at build time.
+    #
+    # This is safe for the build process, b/c the build process is a
+    # throwaway environment, but it is kind of dirty.
+    #
+    # TODO: Think about how to avoid this fix and do something cleaner.
+    for s in pkg.spec.traverse(): s.package.spec = s
+
     set_compiler_environment_variables(pkg, spack_env)
     set_build_environment_variables(pkg, spack_env)
-
-    # If a user makes their own package repo, e.g.
-    # spack.repos.mystuff.libelf.Libelf, and they inherit from
-    # an existing class like spack.repos.original.libelf.Libelf,
-    # then set the module variables for both classes so the
-    # parent class can still use them if it gets called.
-    modules = parent_class_modules(pkg.__class__)
-    for mod in modules:
-        set_module_variables_for_package(pkg, mod)
+    setup_module_variables_for_dag(pkg)
 
     # Allow dependencies to modify the module
-    for dependency_spec in pkg.spec.traverse(root=False):
+    spec = pkg.spec
+    for dependency_spec in spec.traverse(root=False):
         dpkg = dependency_spec.package
-        dpkg.setup_dependent_python_module(pkg.module, pkg.spec)
+        dpkg.setup_dependent_package(pkg.module, spec)
 
     # Allow dependencies to set up environment as well
-    for dependency_spec in pkg.spec.traverse(root=False):
+    for dependency_spec in spec.traverse(root=False):
         dpkg = dependency_spec.package
-        dpkg.setup_dependent_environment(spack_env, run_env, pkg.spec)
+        dpkg.setup_dependent_environment(spack_env, run_env, spec)
 
     # Allow the package to apply some settings.
     pkg.setup_environment(spack_env, run_env)
diff --git a/lib/spack/spack/cmd/info.py b/lib/spack/spack/cmd/info.py
index e7abe7f4a5..c93db55c63 100644
--- a/lib/spack/spack/cmd/info.py
+++ b/lib/spack/spack/cmd/info.py
@@ -52,7 +52,7 @@ def print_text_info(pkg):
     print "Safe versions:  "
 
     if not pkg.versions:
-        print("None")
+        print("    None")
     else:
         pad = padder(pkg.versions, 4)
         for v in reversed(sorted(pkg.versions)):
@@ -62,7 +62,7 @@ def print_text_info(pkg):
     print
     print "Variants:"
     if not pkg.variants:
-        print "None"
+        print "    None"
     else:
         pad = padder(pkg.variants, 4)
 
diff --git a/lib/spack/spack/concretize.py b/lib/spack/spack/concretize.py
index 2e576743ec..ed9bf79868 100644
--- a/lib/spack/spack/concretize.py
+++ b/lib/spack/spack/concretize.py
@@ -159,6 +159,10 @@ class DefaultConcretizer(object):
              if any(v.satisfies(sv) for sv in spec.versions)],
             cmp=cmp_versions)
 
+        def prefer_key(v):
+            return pkg.versions.get(Version(v)).get('preferred', False)
+        valid_versions.sort(key=prefer_key, reverse=True)
+
         if valid_versions:
             spec.versions = ver([valid_versions[0]])
         else:
diff --git a/lib/spack/spack/config.py b/lib/spack/spack/config.py
index 6afd69b3ac..14e5aaf4fb 100644
--- a/lib/spack/spack/config.py
+++ b/lib/spack/spack/config.py
@@ -237,7 +237,29 @@ section_schemas = {
                                 'type' : 'object',
                                 'default' : {},
                             }
-                        },},},},},}
+                        },},},},},},
+    'modules': {
+        '$schema': 'http://json-schema.org/schema#',
+        'title': 'Spack module file configuration file schema',
+        'type': 'object',
+        'additionalProperties': False,
+        'patternProperties': {
+            r'modules:?': {
+                'type': 'object',
+                'default': {},
+                'additionalProperties': False,
+                'properties': {
+                    'enable': {
+                        'type': 'array',
+                        'default': [],
+                        'items': {
+                            'type': 'string'
+                        }
+                    }
+                }
+            },
+        },
+    },
 }
 
 """OrderedDict of config scopes keyed by name.
@@ -405,11 +427,11 @@ def _read_config_file(filename, schema):
             validate_section(data, schema)
         return data
 
-    except MarkedYAMLError, e:
+    except MarkedYAMLError as e:
         raise ConfigFileError(
             "Error parsing yaml%s: %s" % (str(e.context_mark), e.problem))
 
-    except IOError, e:
+    except IOError as e:
         raise ConfigFileError(
             "Error reading configuration file %s: %s" % (filename, str(e)))
 
diff --git a/lib/spack/spack/fetch_strategy.py b/lib/spack/spack/fetch_strategy.py
index 0d0a7db8a9..4ea87bea7e 100644
--- a/lib/spack/spack/fetch_strategy.py
+++ b/lib/spack/spack/fetch_strategy.py
@@ -289,8 +289,14 @@ class URLFetchStrategy(FetchStrategy):
         if not self.archive_file:
             raise NoArchiveFileError("Tried to reset URLFetchStrategy before fetching",
                                      "Failed on reset() for URL %s" % self.url)
-        if self.stage.source_path:
-            shutil.rmtree(self.stage.source_path, ignore_errors=True)
+
+        # Remove everythigng but the archive from the stage
+        for filename in os.listdir(self.stage.path):
+            abspath = os.path.join(self.stage.path, filename)
+            if abspath != self.archive_file:
+                shutil.rmtree(abspath, ignore_errors=True)
+
+        # Expand the archive again
         self.expand()
 
     def __repr__(self):
diff --git a/lib/spack/spack/modules.py b/lib/spack/spack/modules.py
index 05c93cd3e6..f6a11c92e3 100644
--- a/lib/spack/spack/modules.py
+++ b/lib/spack/spack/modules.py
@@ -48,6 +48,7 @@ import textwrap
 
 import llnl.util.tty as tty
 import spack
+import spack.config
 from llnl.util.filesystem import join_path, mkdirp
 from spack.environment import *
 
@@ -56,6 +57,8 @@ __all__ = ['EnvModule', 'Dotkit', 'TclModule']
 # Registry of all types of modules.  Entries created by EnvModule's metaclass
 module_types = {}
 
+CONFIGURATION = spack.config.get_config('modules')
+
 
 def print_help():
     """For use by commands to tell user how to activate shell support."""
@@ -115,7 +118,7 @@ class EnvModule(object):
     class __metaclass__(type):
         def __init__(cls, name, bases, dict):
             type.__init__(cls, name, bases, dict)
-            if cls.name != 'env_module':
+            if cls.name != 'env_module' and cls.name in CONFIGURATION['enable']:
                 module_types[cls.name] = cls
 
     def __init__(self, spec=None):
@@ -158,13 +161,13 @@ class EnvModule(object):
 
         # Let the extendee modify their extensions before asking for
         # package-specific modifications
-        for extendee in self.pkg.extendees:
-            extendee_spec = self.spec[extendee]
-            extendee_spec.package.modify_module(
-                self.pkg.module, extendee_spec, self.spec)
+        spack_env = EnvironmentModifications()
+        for item in self.pkg.extendees:
+            package = self.spec[item].package
+            package.setup_dependent_package(self.pkg.module, self.spec)
+            package.setup_dependent_environment(spack_env, env, self.spec)
 
         # Package-specific environment modifications
-        spack_env = EnvironmentModifications()
         self.spec.package.setup_environment(spack_env, env)
 
         # TODO : implement site-specific modifications and filters
@@ -275,6 +278,6 @@ class TclModule(EnvModule):
         # Long description
         if self.long_description:
             module_file.write('proc ModulesHelp { } {\n')
-            doc = re.sub(r'"', '\"', self.long_description)
-            module_file.write("puts stderr \"%s\"\n" % doc)
+            for line in textwrap.wrap(self.long_description, 72):
+                module_file.write("puts stderr \"%s\"\n" % line)
             module_file.write('}\n\n')
diff --git a/lib/spack/spack/package.py b/lib/spack/spack/package.py
index 9d8ac87bd7..9af3221837 100644
--- a/lib/spack/spack/package.py
+++ b/lib/spack/spack/package.py
@@ -1075,7 +1075,7 @@ class Package(object):
         self.setup_environment(spack_env, run_env)
 
 
-    def setup_dependent_python_module(self, module, dependent_spec):
+    def setup_dependent_package(self, module, dependent_spec):
         """Set up Python module-scope variables for dependent packages.
 
         Called before the install() method of dependents.
diff --git a/lib/spack/spack/test/cc.py b/lib/spack/spack/test/cc.py
index f3f6d4a22e..0b1aeb2a8f 100644
--- a/lib/spack/spack/test/cc.py
+++ b/lib/spack/spack/test/cc.py
@@ -28,6 +28,8 @@ arguments correctly.
 """
 import os
 import unittest
+import tempfile
+import shutil
 
 from llnl.util.filesystem import *
 import spack
@@ -55,13 +57,40 @@ class CompilerTest(unittest.TestCase):
         self.ld = Executable(join_path(spack.build_env_path, "ld"))
         self.cpp = Executable(join_path(spack.build_env_path, "cpp"))
 
-        os.environ['SPACK_CC'] = "/bin/mycc"
-        os.environ['SPACK_PREFIX'] = "/usr"
+        self.realcc = "/bin/mycc"
+        self.prefix = "/spack-test-prefix"
+
+        os.environ['SPACK_CC'] = self.realcc
+        os.environ['SPACK_PREFIX'] = self.prefix
         os.environ['SPACK_ENV_PATH']="test"
         os.environ['SPACK_DEBUG_LOG_DIR'] = "."
         os.environ['SPACK_COMPILER_SPEC'] = "gcc@4.4.7"
         os.environ['SPACK_SHORT_SPEC'] = "foo@1.2"
 
+        # Make some fake dependencies
+        self.tmp_deps = tempfile.mkdtemp()
+        self.dep1 = join_path(self.tmp_deps, 'dep1')
+        self.dep2 = join_path(self.tmp_deps, 'dep2')
+        self.dep3 = join_path(self.tmp_deps, 'dep3')
+        self.dep4 = join_path(self.tmp_deps, 'dep4')
+
+        mkdirp(join_path(self.dep1, 'include'))
+        mkdirp(join_path(self.dep1, 'lib'))
+
+        mkdirp(join_path(self.dep2, 'lib64'))
+
+        mkdirp(join_path(self.dep3, 'include'))
+        mkdirp(join_path(self.dep3, 'lib64'))
+
+        mkdirp(join_path(self.dep4, 'include'))
+
+        if 'SPACK_DEPENDENCIES' in os.environ:
+            del os.environ['SPACK_DEPENDENCIES']
+
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp_deps, True)
+
 
     def check_cc(self, command, args, expected):
         os.environ['SPACK_TEST_COMMAND'] = command
@@ -92,6 +121,10 @@ class CompilerTest(unittest.TestCase):
         self.check_cpp('dump-mode', [], "cpp")
 
 
+    def test_as_mode(self):
+        self.check_cc('dump-mode', ['-S'], "as")
+
+
     def test_ccld_mode(self):
         self.check_cc('dump-mode', [], "ccld")
         self.check_cc('dump-mode', ['foo.c', '-o', 'foo'], "ccld")
@@ -104,27 +137,85 @@ class CompilerTest(unittest.TestCase):
         self.check_ld('dump-mode', ['foo.o', 'bar.o', 'baz.o', '-o', 'foo', '-Wl,-rpath,foo'], "ld")
 
 
-    def test_includes(self):
-        self.check_cc('dump-includes', test_command,
-                      "\n".join(["/test/include", "/other/include"]))
+    def test_dep_rpath(self):
+        """Ensure RPATHs for root package are added."""
+        self.check_cc('dump-args', test_command,
+                      self.realcc + ' ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib64 ' +
+                      ' '.join(test_command))
+
+
+    def test_dep_include(self):
+        """Ensure a single dependency include directory is added."""
+        os.environ['SPACK_DEPENDENCIES'] = self.dep4
+        self.check_cc('dump-args', test_command,
+                      self.realcc + ' ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib64 ' +
+                      '-I' + self.dep4 + '/include ' +
+                      ' '.join(test_command))
+
+
+    def test_dep_lib(self):
+        """Ensure a single dependency RPATH is added."""
+        os.environ['SPACK_DEPENDENCIES'] = self.dep2
+        self.check_cc('dump-args', test_command,
+                      self.realcc + ' ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib64 ' +
+                      '-L' + self.dep2 + '/lib64 ' +
+                      '-Wl,-rpath,' + self.dep2 + '/lib64 ' +
+                      ' '.join(test_command))
+
+
+    def test_all_deps(self):
+        """Ensure includes and RPATHs for all deps are added. """
+        os.environ['SPACK_DEPENDENCIES'] = ':'.join([
+            self.dep1, self.dep2, self.dep3, self.dep4])
+
+        # This is probably more constrained than it needs to be; it
+        # checks order within prepended args and doesn't strictly have
+        # to.  We could loosen that if it becomes necessary
+        self.check_cc('dump-args', test_command,
+                      self.realcc + ' ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib ' +
+                      '-Wl,-rpath,' + self.prefix + '/lib64 ' +
+
+                      '-I' + self.dep4 + '/include ' +
+
+                      '-L' + self.dep3 + '/lib64 ' +
+                      '-Wl,-rpath,' + self.dep3 + '/lib64 ' +
+                      '-I' + self.dep3 + '/include ' +
+
+                      '-L' + self.dep2 + '/lib64 ' +
+                      '-Wl,-rpath,' + self.dep2 + '/lib64 ' +
+
+                      '-L' + self.dep1 + '/lib ' +
+                      '-Wl,-rpath,' + self.dep1 + '/lib ' +
+                      '-I' + self.dep1 + '/include ' +
+
+                      ' '.join(test_command))
 
 
-    def test_libraries(self):
-        self.check_cc('dump-libraries', test_command,
-                      "\n".join(["/test/lib", "/other/lib"]))
+    def test_ld_deps(self):
+        """Ensure no (extra) -I args or -Wl, are passed in ld mode."""
+        os.environ['SPACK_DEPENDENCIES'] = ':'.join([
+            self.dep1, self.dep2, self.dep3, self.dep4])
 
+        self.check_ld('dump-args', test_command,
+                      'ld ' +
+                      '-rpath ' + self.prefix + '/lib ' +
+                      '-rpath ' + self.prefix + '/lib64 ' +
 
-    def test_libs(self):
-        self.check_cc('dump-libs', test_command,
-                      "\n".join(["lib1", "lib2", "lib3", "lib4"]))
+                      '-L' + self.dep3 + '/lib64 ' +
+                      '-rpath ' + self.dep3 + '/lib64 ' +
 
+                      '-L' + self.dep2 + '/lib64 ' +
+                      '-rpath ' + self.dep2 + '/lib64 ' +
 
-    def test_rpaths(self):
-        self.check_cc('dump-rpaths', test_command,
-                      "\n".join(["/first/rpath", "/second/rpath", "/third/rpath", "/fourth/rpath"]))
+                      '-L' + self.dep1 + '/lib ' +
+                      '-rpath ' + self.dep1 + '/lib ' +
 
+                      ' '.join(test_command))
 
-    def test_other_args(self):
-        self.check_cc('dump-other-args', test_command,
-                      "\n".join(["arg1", "-Wl,--start-group", "arg2", "arg3", "arg4",
-                                 "-Wl,--end-group", "arg5", "arg6"]))
diff --git a/lib/spack/spack/test/concretize.py b/lib/spack/spack/test/concretize.py
index 08cce09674..9cd8c969ae 100644
--- a/lib/spack/spack/test/concretize.py
+++ b/lib/spack/spack/test/concretize.py
@@ -24,6 +24,7 @@
 ##############################################################################
 import spack
 from spack.spec import Spec, CompilerSpec
+from spack.version import ver
 from spack.concretize import find_spec
 from spack.test.mock_packages_test import *
 
@@ -77,6 +78,14 @@ class ConcretizeTest(MockPackagesTest):
         self.check_concretize('mpich')
 
 
+    def test_concretize_preferred_version(self):
+        spec = self.check_concretize('python')
+        self.assertEqual(spec.versions, ver('2.7.11'))
+
+        spec = self.check_concretize('python@3.5.1')
+        self.assertEqual(spec.versions, ver('3.5.1'))
+
+
     def test_concretize_with_virtual(self):
         self.check_concretize('mpileaks ^mpi')
         self.check_concretize('mpileaks ^mpi@:1.1')