[semantic changes] Use .getAllDependencies instead of .dependencies i…

…n Project.

source/dub/project.d

@@ -161,13 +161,18 @@ class Project {
 
 				auto cfg = configs.get(p.name, null);
 
-				foreach (dn; p.dependencies.byKey.array.sort()) {
-					auto dv = p.dependencies[dn];
-					// filter out dependencies not in the current configuration set
-					if (!p.hasDependency(dn, cfg)) continue;
-					auto dependency = getDependency(dn, true);
-					assert(dependency || dv.optional,
-						format("Non-optional dependency %s of %s not found in dependency tree!?.", dn, p.name));
+				PackageDependency[] deps;
+				if (!configs) deps = p.getAllDependencies();
+				else {
+					auto depmap = p.getDependencies(cfg);
+					deps = depmap.keys.map!(k => PackageDependency(k, depmap[k])).array;
+					deps.sort!((a, b) => a.name < b.name);
+				}
+
+				foreach (d; deps) {
+					auto dependency = getDependency(d.name, true);
+					assert(dependency || d.spec.optional,
+						format("Non-optional dependency %s of %s not found in dependency tree!?.", d.name, p.name));
 					if(dependency) perform_rec(dependency);
 					if( ret ) return;
 				}
@@ -244,31 +249,30 @@ class Project {
 		}
 		enforce(!m_rootPackage.name.canFind(' '), "Aborting due to the package name containing spaces.");
 
-		foreach (dn, ds; m_rootPackage.dependencies)
-			if (ds.isExactVersion && ds.version_.isBranch) {
+		foreach (d; m_rootPackage.getAllDependencies())
+			if (d.spec.isExactVersion && d.spec.version_.isBranch) {
 				logWarn("WARNING: A deprecated branch based version specification is used "
 					~ "for the dependency %s. Please use numbered versions instead. Also "
 					~ "note that you can still use the %s file to override a certain "
 					~ "dependency to use a branch instead.",
-					dn, SelectedVersions.defaultFile);
+					d.name, SelectedVersions.defaultFile);
 			}
 
-		bool[string] visited;
+		bool[Package] visited;
 		void validateDependenciesRec(Package pack) {
-			foreach (name, vspec_; pack.dependencies) {
-				if (name in visited) continue;
-				visited[name] = true;
-
-				auto basename = getBasePackageName(name);
+			foreach (d; pack.getAllDependencies()) {
+				auto basename = getBasePackageName(d.name);
 				if (m_selections.hasSelectedVersion(basename)) {
 					auto selver = m_selections.getSelectedVersion(basename);
-					if (vspec_.merge(selver) == Dependency.invalid) {
+					if (d.spec.merge(selver) == Dependency.invalid) {
 						logWarn("Selected package %s %s does not match the dependency specification %s in package %s. Need to \"dub upgrade\"?",
-							basename, selver, vspec_, pack.name);
+							basename, selver, d.spec, pack.name);
 					}
 				}
 
 				auto deppack = getDependency(name, true);
+				if (deppack in visited) continue;
+				visited[deppack] = true;
 				if (deppack) validateDependenciesRec(deppack);
 			}
 		}
@@ -287,12 +291,12 @@ class Project {
 			logDebug("%sCollecting dependencies for %s", indent, pack.name);
 			indent ~= "  ";
 
-			foreach (name, vspec_; pack.dependencies) {
-				Dependency vspec = vspec_;
+			foreach (dep; pack.getAllDependencies()) {
+				Dependency vspec = dep.spec;
 				Package p;
 
-				auto basename = getBasePackageName(name);
-				if (name == m_rootPackage.basePackage.name) {
+				auto basename = getBasePackageName(dep.name);
+				if (dep.name == m_rootPackage.basePackage.name) {
 					vspec = Dependency(m_rootPackage.version_);
 					p = m_rootPackage.basePackage;
 				} else if (basename == m_rootPackage.basePackage.name) {
@@ -371,8 +375,8 @@ class Project {
 		string[][string] parents;
 		parents[m_rootPackage.name] = null;
 		foreach (p; getTopologicalPackageList())
-			foreach (d; p.dependencies.byKey)
-				parents[d] ~= p.name;
+			foreach (d; p.getAllDependencies())
+				parents[d.name] ~= p.name;
 
 
 		size_t createConfig(string pack, string config) {
@@ -436,39 +440,39 @@ class Project {
 			scope (exit) allconfigs_path.length--;
 
 			// first, add all dependency configurations
-			foreach (dn; p.dependencies.byKey) {
-				auto dp = getDependency(dn, true);
+			foreach (d; p.getAllDependencies) {
+				auto dp = getDependency(d.name, true);
 				if (!dp) continue;
 				determineAllConfigs(dp);
 			}
 
 			// for each configuration, determine the configurations usable for the dependencies
 			outer: foreach (c; p.getPlatformConfigurations(platform, p is m_rootPackage && allow_non_library)) {
 				string[][string] depconfigs;
-				foreach (dn; p.dependencies.byKey) {
-					auto dp = getDependency(dn, true);
+				foreach (d; p.getAllDependencies()) {
+					auto dp = getDependency(d.name, true);
 					if (!dp) continue;
 
 					string[] cfgs;
 					auto subconf = p.getSubConfiguration(c, dp, platform);
 					if (!subconf.empty) cfgs = [subconf];
 					else cfgs = dp.getPlatformConfigurations(platform);
-					cfgs = cfgs.filter!(c => haveConfig(dn, c)).array;
+					cfgs = cfgs.filter!(c => haveConfig(d.name, c)).array;
 
 					// if no valid configuration was found for a dependency, don't include the
 					// current configuration
 					if (!cfgs.length) {
 						logDebug("Skip %s %s (missing configuration for %s)", p.name, c, dp.name);
 						continue outer;
 					}
-					depconfigs[dn] = cfgs;
+					depconfigs[d.name] = cfgs;
 				}
 
 				// add this configuration to the graph
 				size_t cidx = createConfig(p.name, c);
-				foreach (dn; p.dependencies.byKey)
-					foreach (sc; depconfigs.get(dn, null))
-						createEdge(cidx, createConfig(dn, sc));
+				foreach (d; p.getAllDependencies())
+					foreach (sc; depconfigs.get(d.name, null))
+						createEdge(cidx, createConfig(d.name, sc));
 			}
 		}
 		if (config.length) createConfig(m_rootPackage.name, config);