/* sbt -- Simple Build Tool
 * Copyright 2008 Mark Harrah, David MacIver
 */
package sbt

import java.io.File
import scala.collection._
import FileUtilities._
import Project._

trait trait Project extends java.lang.Object with sbt.TaskManager with sbt.Dag[sbt.Project] with sbt.BasicEnvironment with ScalaObjectProject extends sbt.TaskManagerTaskManager with sbt.Dag[sbt.Project]Dag[Project] with sbt.BasicEnvironmentBasicEnvironment
{
	/** The logger for this project definition. */
	final val sbt.Loggerlog: sbt.LoggerLogger = => sbt.LoggerlogImpl
	protected def => sbt.LoggerlogImpl: sbt.LoggerLogger = sbt.BufferedLoggernew sbt.BufferedLoggerBufferedLogger(sbt.ConsoleLoggernew sbt.ConsoleLoggerConsoleLogger)
	
	trait trait ActionOption extends java.lang.Object with NotNullActionOption extends NotNullNotNull
	
	/** Basic project information. */
	def => sbt.ProjectInfoinfo: sbt.ProjectInfoProjectInfo
	/** The project name. */
	final def => Stringname: StringString = => Project.this.Property[String]projectName.=> Stringvalue
	/** The project version. */
	final def => sbt.Versionversion: sbt.VersionVersion = => Project.this.Property[sbt.Version]projectVersion.=> sbt.Versionvalue
	/** The project organization. */
	final def => Stringorganization: StringString = => Project.this.Property[String]projectOrganization.=> Stringvalue
	
	final type sbt.ProjectManagerType = sbt.ProjectProject
	final type sbt.Project#TaskManagedTask = Project#sbt.Project#TaskTask
	/** The tasks declared on this project. */
	def => scala.collection.Map[String,Project.this.Task]tasks: scala.collection.Map[String,Project.this.Task]Map[String, Task]
	/** The task methods declared on this project */
	def => scala.collection.Map[String,Project.this.MethodTask]methods: scala.collection.Map[String,Project.this.MethodTask]Map[String, MethodTask]
	/** The names of all available tasks that may be called through `act`.  These include
	* the names of the Tasks in `tasks` and those of all dependencies.*/
	def => Iterable[String]taskNames: Iterable[String]Iterable[String] = => scala.collection.Map[String,sbt.Project#Task]deepTasks.=> Iterator[String]keys.=> List[String]toList
	/** The names of all available method tasks that may be called through `call`.  These
	* only include the names of the MethodTasks in `methods` and not those of dependencies.*/
	def => Iterable[String]methodNames: Iterable[String]Iterable[String] = => scala.collection.Map[String,Project.this.MethodTask]methods.=> Iterator[String]keys.=> List[String]toList
	/** A description of all available method tasks in this project, but not of dependencies. */
	def => StringmethodList: StringString = (scala.collection.Map[String,sbt.Described])StringdescriptionList(=> scala.collection.Map[String,Project.this.MethodTask]methods)
	/** A description of all available tasks in this project and all dependencies.  If there
	* are different tasks with the same name, only one will be included. */
	def => StringtaskList: StringString = (scala.collection.Map[String,sbt.Described])StringdescriptionList(=> scala.collection.Map[String,sbt.Project#Task]deepTasks)
	private def (scala.collection.Map[String,sbt.Described])StringdescriptionList(scala.collection.Map[String,sbt.Described]described: scala.collection.Map[String,sbt.Described]Map[String, Described]): StringString =
	{
		val StringBuilderbuffer = ()StringBuildernew StringBuilderStringBuilder
		for((((String, sbt.Described)) => Unit)Unit(Stringname, sbt.Describedd) <- scala.collection.Map[String,sbt.Described]described)
			StringBuilderbuffer.(String)StringBuilderappend(java.lang.String("\011")"\t" (Any)java.lang.String+ Stringname (Any)java.lang.String+ sbt.Describedd.=> Option[String]description.((String) => java.lang.String)Option[java.lang.String]map(Stringx => java.lang.String(": ")": " (Any)java.lang.String+ Stringx).(=> java.lang.String)java.lang.StringgetOrElse(java.lang.String("")"") (Any)java.lang.String+ java.lang.String("\012")"\n")
		StringBuilderbuffer.()StringtoString
	}
	/** Combines the method task maps of this project and all dependencies.*/
	private[sbt] def => scala.collection.Map[String,sbt.Project#MethodTask]deepMethods: scala.collection.Map[String,sbt.Project#MethodTask]Map[String, Project#MethodTask] = ((sbt.Project) => scala.collection.Map[String,sbt.Project#MethodTask])scala.collection.Map[String,sbt.Project#MethodTask]deep(sbt.Project_.=> scala.collection.Map[String,x$2.MethodTask]methods)
	/** Combines the task maps of this project and all dependencies.*/
	private[sbt] def => scala.collection.Map[String,sbt.Project#Task]deepTasks: scala.collection.Map[String,sbt.Project#Task]Map[String, Project#Task] = ((sbt.Project) => scala.collection.Map[String,sbt.Project#Task])scala.collection.Map[String,sbt.Project#Task]deep(sbt.Project_.=> scala.collection.Map[String,x$3.Task]tasks)
	private def [T]((sbt.Project) => scala.collection.Map[String,T])scala.collection.Map[String,T]deep[>: Nothing <: AnyT]((sbt.Project) => scala.collection.Map[String,T]p: Project => Map[String, T]): scala.collection.Map[String,T]Map[String, T] =
	{
		val scala.collection.jcl.TreeMap[String,T]tasks = scala.collection.jcl.TreeMap[String,T]new jcl.scala.collection.jcl.TreeMap[String,T]TreeMap[String, T]
		for(((sbt.Project) => Unit)UnitdependentProject <- => List[sbt.Project]topologicalSort)
			scala.collection.jcl.TreeMap[String,T]tasks (Iterator[(String, T)])Unit++= (sbt.Project)scala.collection.Map[String,T]p(sbt.ProjectdependentProject).=> Iterator[(String, T)]elements
		scala.collection.jcl.TreeMap[String,T]tasks
	}
	/** A map of names to projects for all subprojects of this project.  These are typically explicitly
	* specified for the project and are different from those specified in the project constructor. The
	* main use within sbt is in ParentProject.*/
	def => scala.collection.Map[String,sbt.Project]subProjects: scala.collection.Map[String,sbt.Project]Map[String, Project] = immutable.object scala.collection.immutable.MapMap.scala.collection.immutable.Map[String,Nothing]empty
	/** The name of this project and the names of all subprojects/dependencies, transitively.*/
	def => Iterable[String]projectNames: Iterable[String]Iterable[String] =
	{
		val scala.collection.mutable.HashSet[String]names = scala.collection.mutable.HashSet[String]new mutable.scala.collection.mutable.HashSet[String]HashSet[String]
		scala.collection.mutable.HashSet[String]names (Iterator[String])Unit++= => scala.collection.Map[String,sbt.Project]subProjects.=> Iterator[String]keys
		for(((sbt.Project) => Unit)UnitdependentProject <- => List[sbt.Project]topologicalSort)
			scala.collection.mutable.HashSet[String]names (Iterator[String])Unit++= sbt.ProjectdependentProject.=> scala.collection.Map[String,dependentProject.Task]tasks.=> Iterator[String]keys
		scala.collection.mutable.HashSet[String]names.=> List[String]toList
	}
	
	def (String,Array[String])Option[String]call(Stringname: StringString, Array[String]parameters: Array[String]Array[String]): Option[String]Option[String] =
	{
		=> scala.collection.Map[String,Project.this.MethodTask]methods.(String)Option[Project.this.MethodTask]get(Stringname) Option[String]match
		{
			Option[String]case Some(Project.this.MethodTaskmethod) =>(sbt.Project#Task,String)Option[String]run((Array[String])Project.this.ManagedTaskmethod(Array[String]parameters), Stringname)
			Some[java.lang.String]case object NoneNone => (java.lang.String)Some[java.lang.String]Some(java.lang.String("Method '")"Method '" (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String("' does not exist.")"' does not exist.")
		}
	}
	private def (sbt.Project#Task,String)Option[String]run(sbt.Project#Tasktask: Project#sbt.Project#TaskTask, StringtaskName: StringString): Option[String]Option[String] =
		impl.(sbt.impl.RunTask.Task,String,Boolean)List[sbt.WorkFailure[sbt.impl.RunTask.Task]]RunTask(sbt.Project#Tasktask, StringtaskName, => BooleanparallelExecution) Option[String]match
		{
			None.typecase object NilNil => object NoneNone
			Some[String]case List[sbt.WorkFailure[sbt.impl.RunTask.Task]]x => (String)Some[String]Some((sbt.WorkFailure[sbt.impl.RunTask.Task]*)scala.collection.immutable.Set[sbt.WorkFailure[sbt.impl.RunTask.Task]]Set(List[sbt.WorkFailure[sbt.impl.RunTask.Task]]x: _*).(String)StringmkString(java.lang.String("\012")"\n"))
		}
		
	/** Executes the task with the given name.  This involves executing the task for all
	* project dependencies (transitive) and then for this project.  Not every dependency
	* must define a task with the given name.  If this project and all dependencies
	* do not define a task with the given name, an error is generated indicating this.*/
	def (String)Option[String]act(Stringname: StringString): Option[String]Option[String] =
	{
		val List[sbt.Project]ordered = => List[sbt.Project]topologicalSort
		val List[sbt.Project#Task]definedTasks = List[sbt.Project]ordered.((sbt.Project) => Iterable[sbt.Project#Task])List[sbt.Project#Task]flatMap(sbt.Project_.=> scala.collection.Map[String,x$4.Task]tasks.(String)Option[x$4.Task]get(Stringname).=> List[x$4.Task]toList)
		def (String)Project.this.TaskvirtualTask(Stringname: StringString): Project.this.TaskTask = Project.this.Tasknew Project.this.TaskTask(object NoneNone, List[sbt.Project#Task]definedTasks.((sbt.Project#Task) => Boolean)List[sbt.Project#Task]filter(=> Boolean!sbt.Project#Task_.=> Booleaninteractive), Boolean(false)false, object NoneNone)

		Option[String]if(List[sbt.Project#Task]definedTasks.=> BooleanisEmpty)
			(java.lang.String)Some[java.lang.String]Some(java.lang.String("Action '")"Action '" (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String("' does not exist.")"' does not exist.")
		else
		{
			=> scala.collection.Map[String,Project.this.Task]tasks.(String)Option[Project.this.Task]get(Stringname) Option[String]match
			{
				Option[String]case object NoneNone =>
					val Project.this.Taskvirtual = (String)Project.this.TaskvirtualTask(Stringname)
					Option[String]if(Project.this.Taskvirtual.=> List[Project.this.ManagedTask]dependencies.=> Intsize (Int)Boolean== List[sbt.Project#Task]definedTasks.=> Intsize)
						(sbt.Project#Task,String)Option[String]run(Project.this.Taskvirtual, Stringname)
					else
					{
						(java.lang.String)Some[java.lang.String]Some(java.lang.String("Cannot run interactive action '")"Cannot run interactive action '" (Any)java.lang.String+ Stringname (Any)java.lang.String+
							java.lang.String("' defined on multiple subprojects (change to the desired project with 'project <name>').")"' defined on multiple subprojects (change to the desired project with 'project <name>').")
					}
				Option[String]case Some(Project.this.Tasktask) => (sbt.Project#Task,String)Option[String]run(Project.this.Tasktask, Stringname)
			}
		}
	}
	
	/** Logs the list of projects at the debug level.*/
	private def (Iterable[sbt.Project])UnitshowBuildOrder(Iterable[sbt.Project]order: Iterable[sbt.Project]Iterable[Project])
	{
		=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Project build order:")"Project build order:")
		Iterable[sbt.Project]order.((sbt.Project) => Unit)Unitforeach(sbt.Projectx => => sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("    ")"    " (Any)java.lang.String+ sbt.Projectx.=> Stringname) )
		=> sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("")"")
	}
	
	/** Converts a String to a path relative to the project directory of this project. */
	implicit def implicit sbt.Project.path : (String)sbt.Pathpath(Stringcomponent: StringString): sbt.PathPath = => sbt.ProjectInfoinfo.=> sbt.ProjectDirectoryprojectPath (String)sbt.Path/ Stringcomponent
	/** Converts a String to a simple name filter.  * has the special meaning: zero or more of any character */
	implicit def implicit sbt.Project.filter : (String)sbt.NameFilterfilter(StringsimplePattern: StringString): sbt.NameFilterNameFilter = (String)sbt.NameFilterGlobFilter(StringsimplePattern)
	
	/** Loads the project at the given path and declares the project to have the given
	* dependencies.  This method will configure the project according to the
	* project/ directory in the directory denoted by path.*/
	def (sbt.Path,sbt.Project*)sbt.Projectproject(sbt.Pathpath: sbt.PathPath, sbt.Project*deps: sbt.Project*Project*): sbt.ProjectProject = (sbt.LoadResult,sbt.Path)sbt.ProjectgetProject(object sbt.ProjectProject.(sbt.Path,Iterable[sbt.Project],Option[sbt.Project],sbt.Logger)sbt.LoadResultloadProject(sbt.Pathpath, sbt.Project*deps, (sbt.Project)Some[sbt.Project]Some(sbt.Projectthis), => sbt.Loggerlog), sbt.Pathpath)
	
	/** Loads the project at the given path using the given name and inheriting this project's version.
	* The builder class is the default builder class, sbt.DefaultProject. The loaded project is declared
	* to have the given dependencies. Any project/build/ directory for the project is ignored.*/
	def (sbt.Path,String,sbt.Project*)sbt.Projectproject(sbt.Pathpath: sbt.PathPath, Stringname: StringString, sbt.Project*deps: sbt.Project*Project*): sbt.ProjectProject = (sbt.Path,String,Class[?0],sbt.Project*)?0project(sbt.Pathpath, Stringname, object sbt.ProjectProject.=> java.lang.Class[_ <: sbt.Project]DefaultBuilderClass, sbt.Project*deps: _*)
	
	/** Loads the project at the given path using the given name and inheriting it's version from this project.
	* The Project implementation used is given by builderClass.  The dependencies are declared to be
	* deps. Any project/build/ directory for the project is ignored.*/
	def [P <: sbt.Project](sbt.Path,String,Class[P],sbt.Project*)Pproject[>: Nothing <: sbt.ProjectP <: Project](sbt.Pathpath: sbt.PathPath, Stringname: StringString, Class[P]builderClass: Class[P]Class[P], sbt.Project*deps: sbt.Project*Project*): PP =
	{
		(Boolean,=> Any)Unitrequire(Class[P]builderClass (AnyRef)Boolean!= Project.this.typethis.()java.lang.Class[_ <: java.lang.Object]getClass, java.lang.String("Cannot recursively construct projects of same type: ")"Cannot recursively construct projects of same type: " (Any)java.lang.String+ Class[P]builderClass.()java.lang.StringgetName)
		(sbt.Path,String,(sbt.ProjectInfo) => P,sbt.Project*)Pproject(sbt.Pathpath, Stringname, sbt.ProjectInfoinfo => object sbt.ProjectProject.(sbt.ProjectInfo,Class[P])PconstructProject(sbt.ProjectInfoinfo, Class[P]builderClass), sbt.Project*deps: _*)
	}
	/** Loads the project at the given path using the given name and inheriting it's version from this project.
	* The construct function is used to obtain the Project instance. Any project/build/ directory for the project
	* is ignored.  The project is declared to have the dependencies given by deps.*/
	def [P <: sbt.Project](sbt.Path,String,(sbt.ProjectInfo) => P,sbt.Project*)Pproject[>: Nothing <: sbt.ProjectP <: Project](sbt.Pathpath: sbt.PathPath, Stringname: StringString, (sbt.ProjectInfo) => Pconstruct: ProjectInfo => P, sbt.Project*deps: sbt.Project*Project*): PP =
		(P,Option[sbt.SetupInfo],sbt.Logger)Pinitialize((sbt.ProjectInfo)Pconstruct((java.io.File,Iterable[sbt.Project],Option[sbt.Project])sbt.ProjectInfoProjectInfo(sbt.Pathpath.=> java.io.FileasFile, sbt.Project*deps, (sbt.Project)Some[sbt.Project]Some(sbt.Projectthis))), (sbt.SetupInfo)Some[sbt.SetupInfo]Some(sbt.SetupInfonew sbt.SetupInfoSetupInfo(Stringname, object NoneNone, object NoneNone, Boolean(false)false)), => sbt.Loggerlog)
	
	/** Initializes the project directories when a user has requested that sbt create a new project.*/
	def ()UnitinitializeDirectories() Unit{}
	/** True if projects should be run in parallel, false if they should run sequentially.
	*  This only has an effect for multi-projects.*/
	def => BooleanparallelExecution = Boolean(false)false
	
	/** True if a project and its dependencies should be checked to ensure that their
	* output directories are not the same, false if they should not be checked. */
	def => BooleanshouldCheckOutputDirectories = Boolean(true)true
	
	/** The list of directories to which this project writes.  This is used to verify that multiple
	* projects have not been defined with the same output directories. */
	def => Iterable[sbt.Path]outputDirectories: Iterable[sbt.Path]Iterable[Path] = => sbt.PathoutputPath (sbt.Path)List[sbt.Path]:: object NilNil
	
	/** The path to the file that provides persistence for properties.*/
	final def => sbt.PathenvBackingPath = => sbt.ProjectInfoinfo.=> sbt.PathbuilderPath (String)sbt.Path/ object sbt.ProjectProject.=> java.lang.StringDefaultEnvBackingName
	/** The path to the file that provides persistence for history. */
	def => Some[sbt.Path]historyPath = (sbt.Path)Some[sbt.Path]Some(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String(".history")".history")
	def => sbt.PathoutputPath = implicit sbt.Project.path : (String)sbt.Pathpath(=> java.lang.StringoutputDirectoryName)
	def => java.lang.StringoutputDirectoryName = => java.lang.StringDefaultOutputDirectoryName
	
	private def (sbt.LoadResult,sbt.Path)sbt.ProjectgetProject(sbt.LoadResultresult: sbt.LoadResultLoadResult, sbt.Pathpath: sbt.PathPath): sbt.ProjectProject =
		sbt.LoadResultresult sbt.Projectmatch
		{
			Nothingcase object sbt.LoadSetupDeclinedLoadSetupDeclined => object PredefPredef.(String)Nothingerror(java.lang.String("No project exists at path ")"No project exists at path " (Any)java.lang.String+ sbt.Pathpath)
			Nothingcase sbt.LoadSetupErrorlse: sbt.LoadSetupErrorLoadSetupError => object PredefPredef.(String)Nothingerror(java.lang.String("Error setting up new project at path ")"Error setting up new project at path " (Any)java.lang.String+ object sbt.PathPath (Any)java.lang.String+ java.lang.String(" : ")" : " (Any)java.lang.String+ sbt.LoadSetupErrorlse.=> Stringmessage)
			Nothingcase sbt.LoadErrorerr: sbt.LoadErrorLoadError => object PredefPredef.(String)Nothingerror(java.lang.String("Error loading project at path ")"Error loading project at path " (Any)java.lang.String+ sbt.Pathpath (Any)java.lang.String+ java.lang.String(" : ")" : " (Any)java.lang.String+ sbt.LoadErrorerr.=> Stringmessage)
			sbt.Projectcase sbt.LoadSuccesssuccess: sbt.LoadSuccessLoadSuccess => sbt.LoadSuccesssuccess.=> sbt.Projectproject
		}
	
	/** The property for the project's version. */
	final val Project.this.Property[sbt.Version]projectVersion = (implicit scala.reflect.Manifest[sbt.Version],sbt.Format[sbt.Version])Project.this.Property[sbt.Version]property[sbt.VersionVersion]
	/** The property for the project's name. */
	final val Project.this.Property[String]projectName = (sbt.Format[String])(implicit scala.reflect.Manifest[String])Project.this.Property[String]propertyLocalF[StringString](=> sbt.Format[String]NonEmptyStringFormat)
	/** The property for the project's organization.  Defaults to the parent project's organization or the project name if there is no parent. */
	final val Project.this.Property[String]projectOrganization = (=> String,Boolean)(implicit scala.reflect.Manifest[String],sbt.Format[String])Project.this.Property[String]propertyOptional[StringString](=> Stringname, Boolean(true)true)
	final val Project.this.Property[String]scalaVersion = (=> String)(implicit scala.reflect.Manifest[String],sbt.Format[String])Project.this.Property[String]propertyOptional[StringString](java.lang.String("")"")
	final val Project.this.Property[String]sbtVersion = (=> String)(implicit scala.reflect.Manifest[String],sbt.Format[String])Project.this.Property[String]propertyOptional[StringString](java.lang.String("")"")
	final val Project.this.Property[Boolean]projectInitialize = (=> Boolean)(implicit scala.reflect.Manifest[Boolean],sbt.Format[Boolean])Project.this.Property[Boolean]propertyOptional[BooleanBoolean](Boolean(false)false)
	
	protected final override def => Option[sbt.Project]parentEnvironment = => sbt.ProjectInfoinfo.=> Option[sbt.Project]parent
	
	// .* included because svn doesn't mark .svn hidden
	def => sbt.FileFilterdefaultExcludes: sbt.FileFilterFileFilter = implicit sbt.Project.filter : (String)sbt.NameFilter".*" (sbt.FileFilter)sbt.FileFilter|| object sbt.HiddenFileFilterHiddenFileFilter
	/** Short for parent.descendentsExcept(include, defaultExcludes)*/
	def (sbt.PathFinder,sbt.FileFilter)sbt.PathFinderdescendents(sbt.PathFinderparent: sbt.PathFinderPathFinder, sbt.FileFilterinclude: sbt.FileFilterFileFilter) = sbt.PathFinderparent.(sbt.FileFilter,sbt.FileFilter)sbt.PathFinderdescendentsExcept(sbt.FileFilterinclude, => sbt.FileFilterdefaultExcludes)
	override def ()java.lang.StringtoString = java.lang.String("Project ")"Project " (Any)java.lang.String+ => Project.this.Property[String]projectName.=> Option[String]get.(=> String)StringgetOrElse(java.lang.String("at ")"at " (Any)java.lang.String+ => java.lang.StringenvironmentLabel)
	
	def => java.lang.StringnormalizedName = => Stringname.()java.lang.StringtoLowerCase.(java.lang.String,java.lang.String)java.lang.StringreplaceAll(java.lang.String("\s+")"""\s+""", java.lang.String("-")"-")
}
private[sbt] sealed trait trait LoadResult extends java.lang.Object with NotNullLoadResult extends NotNullNotNull
private[sbt] final class class LoadSuccess extends java.lang.Object with sbt.LoadResult with ScalaObjectLoadSuccess(val sbt.Projectproject: sbt.ProjectProject) extends sbt.LoadResultLoadResult
private[sbt] final class class LoadError extends java.lang.Object with sbt.LoadResult with ScalaObjectLoadError(val Stringmessage: StringString) extends sbt.LoadResultLoadResult
private[sbt] final object object sbt.LoadSetupDeclinedLoadSetupDeclined extends sbt.LoadResultLoadResult
private[sbt] final class class LoadSetupError extends java.lang.Object with sbt.LoadResult with ScalaObjectLoadSetupError(val Stringmessage: StringString) extends sbt.LoadResultLoadResult

object object sbt.ProjectProject
{
	val java.lang.StringBootDirectoryName = java.lang.String("boot")"boot"
	val java.lang.StringDefaultOutputDirectoryName = java.lang.String("target")"target"
	val java.lang.StringDefaultEnvBackingName = java.lang.String("build.properties")"build.properties"
	val java.lang.StringDefaultBuilderClassName = java.lang.String("sbt.DefaultProject")"sbt.DefaultProject"
	val java.lang.Class[_ <: sbt.Project]DefaultBuilderClass = object java.lang.ClassClass.(java.lang.String)java.lang.Class[_]forName(=> java.lang.StringDefaultBuilderClassName).(java.lang.Class[sbt.Project])java.lang.Class[_ <: sbt.Project]asSubclass(java.lang.Class[sbt.Project]classOf[Project])
	
	/** The name of the directory for project definitions.*/
	val java.lang.StringBuilderProjectDirectoryName = java.lang.String("build")"build"
	/** The name of the class that all projects must inherit from.*/
	val java.lang.StringProjectClassName = java.lang.Class[sbt.Project]classOf[Project].()java.lang.StringgetName
	
	/** The logger that should be used before the root project definition is loaded.*/
	private[sbt] def => sbt.ConsoleLoggerbootLogger =
	{
		val sbt.ConsoleLoggerlog = sbt.ConsoleLoggernew sbt.ConsoleLoggerConsoleLogger
		sbt.ConsoleLoggerlog.(sbt.Level.Value)UnitsetLevel(object sbt.LevelLevel.=> sbt.Level.ValueDebug)
		sbt.ConsoleLoggerlog.(Boolean)UnitenableTrace(Boolean(true)true)
		sbt.ConsoleLoggerlog
	}
	
	/** Loads the project in the current working directory.*/
	private[sbt] def => sbt.LoadResultloadProject: sbt.LoadResultLoadResult = (sbt.Logger)sbt.LoadResultloadProject(=> sbt.ConsoleLoggerbootLogger)
	/** Loads the project in the current working directory.*/
	private[sbt] def (sbt.Logger)sbt.LoadResultloadProject(sbt.Loggerlog: sbt.LoggerLogger): sbt.LoadResultLoadResult = (sbt.LoadResult)sbt.LoadResultcheckOutputDirectories((java.io.File,Iterable[sbt.Project],Option[sbt.Project],sbt.Logger)sbt.LoadResultloadProject(java.io.Filenew java.io.FileFile(java.lang.String(".")"."), object NilNil, object NoneNone, sbt.Loggerlog))
	/** Loads the project in the directory given by 'path' and with the given dependencies.*/
	private[sbt] def (sbt.Path,Iterable[sbt.Project],Option[sbt.Project],sbt.Logger)sbt.LoadResultloadProject(sbt.Pathpath: sbt.PathPath, Iterable[sbt.Project]deps: Iterable[sbt.Project]Iterable[Project], Option[sbt.Project]parent: Option[sbt.Project]Option[Project], sbt.Loggerlog: sbt.LoggerLogger): sbt.LoadResultLoadResult =
		(java.io.File,Iterable[sbt.Project],Option[sbt.Project],sbt.Logger)sbt.LoadResultloadProject(sbt.Pathpath.=> java.io.FileasFile, Iterable[sbt.Project]deps, Option[sbt.Project]parent, sbt.Loggerlog)
	/** Loads the project in the directory given by 'projectDirectory' and with the given dependencies.*/
	private[sbt] def (java.io.File,Iterable[sbt.Project],Option[sbt.Project],sbt.Logger)sbt.LoadResultloadProject(java.io.FileprojectDirectory: java.io.FileFile, Iterable[sbt.Project]deps: Iterable[sbt.Project]Iterable[Project], Option[sbt.Project]parent: Option[sbt.Project]Option[Project], sbt.Loggerlog: sbt.LoggerLogger): sbt.LoadResultLoadResult =
	{
		val sbt.ProjectInfoinfo = (java.io.File,Iterable[sbt.Project],Option[sbt.Project])sbt.ProjectInfoProjectInfo(java.io.FileprojectDirectory, Iterable[sbt.Project]deps, Option[sbt.Project]parent)
		object sbt.ProjectInfoProjectInfo.(sbt.ProjectInfo,sbt.Logger)sbt.SetupResultsetup(sbt.ProjectInfoinfo, sbt.Loggerlog) sbt.LoadResultmatch
		{
			sbt.LoadSetupErrorcase sbt.SetupErrorerr: sbt.SetupErrorSetupError => sbt.LoadSetupErrornew sbt.LoadSetupErrorLoadSetupError(sbt.SetupErrorerr.=> Stringmessage)
			sbt.LoadSetupDeclined.typecase object sbt.SetupDeclinedSetupDeclined => object sbt.LoadSetupDeclinedLoadSetupDeclined
			sbt.LoadResultcase object sbt.AlreadySetupAlreadySetup => (sbt.ProjectInfo,Option[sbt.SetupInfo],sbt.Logger)sbt.LoadResultloadProject(sbt.ProjectInfoinfo, object NoneNone, sbt.Loggerlog)
			sbt.LoadResultcase sbt.SetupInfosetup: sbt.SetupInfoSetupInfo => (sbt.ProjectInfo,Option[sbt.SetupInfo],sbt.Logger)sbt.LoadResultloadProject(sbt.ProjectInfoinfo, (sbt.SetupInfo)Some[sbt.SetupInfo]Some(sbt.SetupInfosetup), sbt.Loggerlog)
		}
	}
	private def (sbt.ProjectInfo,Option[sbt.SetupInfo],sbt.Logger)sbt.LoadResultloadProject(sbt.ProjectInfoinfo: sbt.ProjectInfoProjectInfo, Option[sbt.SetupInfo]setupInfo: Option[sbt.SetupInfo]Option[SetupInfo], sbt.Loggerlog: sbt.LoggerLogger): sbt.LoadResultLoadResult =
	{
		try
		{
			val sbt.Level.ValueoldLevel = sbt.Loggerlog.=> sbt.Level.ValuegetLevel
			sbt.Loggerlog.(sbt.Level.Value)UnitsetLevel(object sbt.LevelLevel.=> sbt.Level.ValueWarn)
			val <refinement> extends Either[String,sbt.Project] with Productresult =
				for(((Class[_ <: sbt.Project]) => sbt.Project)Either[String,sbt.Project] with ProductbuilderClass <- (sbt.ProjectInfo,sbt.Logger)Either[String,Class[_ <: sbt.Project]]getProjectDefinition(sbt.ProjectInfoinfo, sbt.Loggerlog).=> Either.RightProjection[String,Class[_ <: sbt.Project]]right) yield
					(P,Option[sbt.SetupInfo],sbt.Logger)Pinitialize((sbt.ProjectInfo,Class[P])PconstructProject(sbt.ProjectInfoinfo, Class[_ <: sbt.Project]builderClass), Option[sbt.SetupInfo]setupInfo, sbt.Loggerlog)
			sbt.Loggerlog.(sbt.Level.Value)UnitsetLevel(sbt.Level.ValueoldLevel)
			<refinement> extends Either[String,sbt.Project] with Productresult.((String) => sbt.LoadResult with ScalaObject,(sbt.Project) => sbt.LoadResult with ScalaObject)sbt.LoadResult with ScalaObjectfold(sbt.LoadErrornew sbt.LoadErrorLoadError(String_), sbt.LoadSuccessnew sbt.LoadSuccessLoadSuccess(sbt.Project_))
		}
		catch
		{
			sbt.LoadErrorcase java.lang.reflect.InvocationTargetExceptionite: java.lang.reflect.java.lang.reflect.InvocationTargetExceptionInvocationTargetException =>
			{
				val java.lang.Throwablecause =
					java.lang.Throwableif(java.lang.reflect.InvocationTargetExceptionite.()java.lang.ThrowablegetCause (AnyRef)Boolean== Null(null)null) java.lang.reflect.InvocationTargetExceptionite
					else java.lang.reflect.InvocationTargetExceptionite.()java.lang.ThrowablegetCause
				(Throwable,sbt.Logger)sbt.LoadErrorerrorLoadingProject(java.lang.Throwablecause, sbt.Loggerlog)
			}
			sbt.LoadErrorcase java.lang.NoSuchMethodExceptionnme: java.lang.NoSuchMethodExceptionNoSuchMethodException => sbt.LoadErrornew sbt.LoadErrorLoadError(java.lang.String("Constructor with one argument of type sbt.ProjectInfo required for project definition.")"Constructor with one argument of type sbt.ProjectInfo required for project definition.")
			sbt.LoadErrorcase Exceptione: ExceptionException => (Throwable,sbt.Logger)sbt.LoadErrorerrorLoadingProject(Exceptione, sbt.Loggerlog)
		}
	}
	/** Logs the stack trace and returns an error message in Left.*/
	private def (Throwable,sbt.Logger)sbt.LoadErrorerrorLoadingProject(Throwablee: ThrowableThrowable, sbt.Loggerlog: sbt.LoggerLogger) =
	{
		sbt.Loggerlog.(=> Throwable)Unittrace(Throwablee)
		sbt.LoadErrornew sbt.LoadErrorLoadError(java.lang.String("Error loading project: ")"Error loading project: " (Any)java.lang.String+ Throwablee.()java.lang.StringtoString)
	}
	/** Loads the project for the given `info` and represented by an instance of 'builderClass'.*/
	private def [P <: sbt.Project](sbt.ProjectInfo,Class[P])PconstructProject[>: Nothing <: sbt.ProjectP <: Project](sbt.ProjectInfoinfo: sbt.ProjectInfoProjectInfo, Class[P]builderClass: Class[P]Class[P]): PP =
		Class[P]builderClass.(java.lang.Class[_]*)java.lang.reflect.Constructor[P]getConstructor(java.lang.Class[sbt.ProjectInfo]classOf[ProjectInfo]).(java.lang.Object*)PnewInstance(sbt.ProjectInfoinfo)
	/** Checks the project's dependencies, initializes its environment, and possibly its directories.*/
	private def [P <: sbt.Project](P,Option[sbt.SetupInfo],sbt.Logger)Pinitialize[>: Nothing <: sbt.ProjectP <: Project](Pp: PP, Option[sbt.SetupInfo]setupInfo: Option[sbt.SetupInfo]Option[SetupInfo], sbt.Loggerlog: sbt.LoggerLogger): PP =
	{
		Pp.()UnitinitializeEnvironment()
		Option[sbt.SetupInfo]setupInfo Unitmatch
		{
			Unitcase Some(sbt.SetupInfosetup) =>
			{
				Pp.=> p.Property[String]projectName() = sbt.SetupInfosetup.=> Stringname
				for(((sbt.Version) => Unit)Unitv <- sbt.SetupInfosetup.=> Option[sbt.Version]version)
					Pp.=> p.Property[sbt.Version]projectVersion() = sbt.Versionv
				for(((String) => Unit)Unitorg <- sbt.SetupInfosetup.=> Option[String]organization)
					Pp.=> p.Property[String]projectOrganization() = Stringorg
				Unitif(=> Boolean!sbt.SetupInfosetup.=> BooleaninitializeDirectories)
					Pp.(Boolean)UnitsetEnvironmentModified(Boolean(false)false)
				for(((String) => Unit)UniterrorMessage <- Pp.()Option[String]saveEnvironment())
					sbt.Loggerlog.(=> String)Uniterror(StringerrorMessage)
				Unitif(sbt.SetupInfosetup.=> BooleaninitializeDirectories)
					Pp.()UnitinitializeDirectories()
			}
			Unitcase object NoneNone =>
				Unitif(Pp.=> p.Property[Boolean]projectInitialize.=> Booleanvalue)
				{
					Pp.()UnitinitializeDirectories()
					Pp.=> p.Property[Boolean]projectInitialize() = Boolean(false)false
					for(((String) => Unit)UniterrorMessage <- Pp.()Option[String]saveEnvironment())
						sbt.Loggerlog.(=> String)Uniterror(StringerrorMessage)
				}
		}
		val StringuseName = Pp.=> p.Property[String]projectName.=> Option[String]get.(=> String)StringgetOrElse(java.lang.String("at ")"at " (Any)java.lang.String+ Pp.=> sbt.ProjectInfoinfo.=> java.io.FileprojectDirectory.()java.lang.StringgetCanonicalPath)
		(String,Iterable[sbt.Project],sbt.Logger)UnitcheckDependencies(StringuseName, Pp.=> sbt.ProjectInfoinfo.=> Iterable[sbt.Project]dependencies, sbt.Loggerlog)
		Pp
	}
	/** Compiles the project definition classes and returns the project definition class name
	* and the class loader that should be used to load the definition. */
	private def (sbt.ProjectInfo,sbt.Logger)Either[String,Class[_ <: sbt.Project]]getProjectDefinition(sbt.ProjectInfoinfo: sbt.ProjectInfoProjectInfo, sbt.LoggerbuildLog: sbt.LoggerLogger): Either[String,Class[_ <: sbt.Project]]Either[String, Class[P] forSome { type P <: Project }] =
	{
		val sbt.PathbuilderProjectPath = sbt.ProjectInfoinfo.=> sbt.PathbuilderPath (String)sbt.Path/ => java.lang.StringBuilderProjectDirectoryName
		Either[String,Class[_ <: sbt.Project]]if(sbt.PathbuilderProjectPath.=> java.io.FileasFile.()BooleanisDirectory)
		{
			val sbt.BuilderProjectbuilderProject = sbt.BuilderProjectnew sbt.BuilderProjectBuilderProject((java.io.File,Iterable[sbt.Project],Option[sbt.Project])sbt.ProjectInfoProjectInfo(sbt.PathbuilderProjectPath.=> java.io.FileasFile, object NilNil, object NoneNone), sbt.LoggerbuildLog)
			sbt.BuilderProjectbuilderProject.=> builderProject.Taskcompile.=> Option[String]run.(=> Unit)Either[String,Unit] with ProducttoLeft(Unit()).=> Either.RightProjection[String,Unit]right.((Unit) => Either[String,java.lang.Class[_ >: ?0 with ?0 <: sbt.Project]])Either[String,java.lang.Class[_ >: ?0 with ?0 <: sbt.Project]]flatMap { Unitignore =>
				sbt.BuilderProjectbuilderProject.=> Either[String,Option[String]]projectDefinition.=> Either.RightProjection[String,Option[String]]right.((Option[String]) => java.lang.Class[_ >: ?0 with ?0 <: sbt.Project])Either[String,java.lang.Class[_ >: ?0 with ?0 <: sbt.Project]] with Productmap java.lang.Class[_26]{
					java.lang.Class[?0]case Some(Stringdefinition) =>
					{
						val Array[java.net.URL]compileClassPath = sbt.BuilderProjectbuilderProject.=> sbt.PathFinderprojectClasspath.=> scala.collection.Set[sbt.Path]get.((sbt.Path) => java.net.URL)Iterable[java.net.URL]map(sbt.Path_.=> java.net.URLasURL).=> Seq[java.net.URL]toSeq.Array[java.net.URL]toArray
						import java.net.URLClassLoader
						val java.net.URLClassLoaderloader = java.net.URLClassLoadernew java.net.URLClassLoaderURLClassLoader(Array[java.net.URL]compileClassPath, ()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.ClassLoadergetClassLoader)
						val java.lang.Class[_]builderClass = object java.lang.ClassClass.(java.lang.String,Boolean,java.lang.ClassLoader)java.lang.Class[_]forName(Stringdefinition, Boolean(false)false, java.net.URLClassLoaderloader)
						(Boolean,=> Any)Unitrequire(java.lang.Class[sbt.Project]classOf[Project].(java.lang.Class[_])BooleanisAssignableFrom(java.lang.Class[_]builderClass), java.lang.String("Builder class '")"Builder class '" (Any)java.lang.String+ java.lang.Class[_]builderClass (Any)java.lang.String+ java.lang.String("' does not extend Project.")"' does not extend Project.")
						java.lang.Class[_]builderClass.(java.lang.Class[sbt.Project])java.lang.Class[_ <: sbt.Project]asSubclass(java.lang.Class[sbt.Project]classOf[Project])
					}
					java.lang.Class[?0]case object NoneNone => => java.lang.Class[_ <: sbt.Project]DefaultBuilderClass
				}
			}
		}
		else
			(java.lang.Class[?0])Right[Nothing,java.lang.Class[?0]]Right(=> java.lang.Class[_ <: sbt.Project]DefaultBuilderClass)
	}
	/** Verifies that the given list of project dependencies contains no nulls.  The
	* String argument should be the project name with the dependencies.*/
	private def (String,Iterable[sbt.Project],sbt.Logger)UnitcheckDependencies(StringforProject: StringString, Iterable[sbt.Project]deps: Iterable[sbt.Project]Iterable[Project], sbt.Loggerlog: sbt.LoggerLogger)
	{
		for(((sbt.Project) => Unit)UnitnullDep <- Iterable[sbt.Project]deps.((sbt.Project) => Boolean)Option[sbt.Project]find(sbt.Project_ (AnyRef)Boolean== Null(null)null))
		{
			sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Project ")"Project " (Any)java.lang.String+ StringforProject (Any)java.lang.String+ java.lang.String(" had a null dependency.  This is probably an initialization problem and might be due to a circular dependency.")" had a null dependency.  This is probably an initialization problem and might be due to a circular dependency.")
			Nothingthrow (java.lang.String)java.lang.RuntimeExceptionnew java.lang.RuntimeExceptionRuntimeException(java.lang.String("Null dependency in project ")"Null dependency in project " (Any)java.lang.String+ StringforProject)
		}
	}
	/** Verifies that output directories of the given project and all of its dependencies are
	* all different.  No verification is done if the project overrides
	* 'shouldCheckOutputDirectories' to be false. The 'Project.outputDirectories' method is
	* used to determine a project's output directories. */
	private def (sbt.LoadResult)sbt.LoadResultcheckOutputDirectories(sbt.LoadResultresult: sbt.LoadResultLoadResult): sbt.LoadResultLoadResult =
		sbt.LoadResultresult sbt.LoadResultmatch
		{
			sbt.LoadResultcase sbt.LoadSuccesssuccess: sbt.LoadSuccessLoadSuccess =>
				sbt.LoadResultif(sbt.LoadSuccesssuccess.=> sbt.Projectproject.=> BooleanshouldCheckOutputDirectories)
					(sbt.Project)sbt.LoadResultcheckOutputDirectoriesImpl(sbt.LoadSuccesssuccess.=> sbt.Projectproject)
				else
					sbt.LoadSuccesssuccess
			sbt.LoadResultcase sbt.LoadResultx => sbt.LoadResultx
		}
	/** Verifies that output directories of the given project and all of its dependencies are
	* all different.  The 'Project.outputDirectories' method is used to determine a project's
	* output directories. */
	private def (sbt.Project)sbt.LoadResultcheckOutputDirectoriesImpl(sbt.Projectproject: sbt.ProjectProject): sbt.LoadResultLoadResult =
	{
		val List[sbt.Project]projects = sbt.Projectproject.=> List[sbt.Project]topologicalSort
		import scala.collection.mutable.{HashMap, HashSet, Set}
		val scala.collection.mutable.HashMap[sbt.Path,scala.collection.mutable.Set[sbt.Project]]outputDirectories = scala.collection.mutable.HashMap[sbt.Path,scala.collection.mutable.Set[sbt.Project]]new scala.collection.mutable.HashMap[sbt.Path,scala.collection.mutable.Set[sbt.Project]]HashMap[Path, Set[Project]]
		for(((sbt.Project) => Unit)Unitp <- List[sbt.Project]projects; ((sbt.Path) => Unit)Unitpath <- sbt.Projectp.=> Iterable[sbt.Path]outputDirectories)
			scala.collection.mutable.HashMap[sbt.Path,scala.collection.mutable.Set[sbt.Project]]outputDirectories.(sbt.Path,=> scala.collection.mutable.Set[sbt.Project])scala.collection.mutable.Set[sbt.Project]getOrElseUpdate(sbt.Pathpath, scala.collection.mutable.HashSet[sbt.Project]new scala.collection.mutable.HashSet[sbt.Project]HashSet[Project]) (sbt.Project)Unit+= sbt.Projectp
		val Iterable[(sbt.Path, scala.collection.mutable.Set[sbt.Project])]shared = scala.collection.mutable.HashMap[sbt.Path,scala.collection.mutable.Set[sbt.Project]]outputDirectories.(((sbt.Path, scala.collection.mutable.Set[sbt.Project])) => Boolean)Iterable[(sbt.Path, scala.collection.mutable.Set[sbt.Project])]filter((sbt.Path, scala.collection.mutable.Set[sbt.Project])_.=> scala.collection.mutable.Set[sbt.Project]_2.=> Intsize (Int)Boolean> Int(1)1)
		sbt.LoadResultif(Iterable[(sbt.Path, scala.collection.mutable.Set[sbt.Project])]shared.=> BooleanisEmpty)
			sbt.LoadSuccessnew sbt.LoadSuccessLoadSuccess(sbt.Projectproject)
		else
		{
			val StringsharedString =
			{
				val Iterable[java.lang.String]s =
					for((((sbt.Path, scala.collection.mutable.Set[sbt.Project])) => java.lang.String)Iterable[java.lang.String](sbt.Pathpath, scala.collection.mutable.Set[sbt.Project]projectsSharingPath) <- Iterable[(sbt.Path, scala.collection.mutable.Set[sbt.Project])]shared) yield
						scala.collection.mutable.Set[sbt.Project]projectsSharingPath.((sbt.Project) => String)Iterable[String]map(sbt.Project_.=> Stringname).(String)StringmkString(java.lang.String(", ")", ") (Any)java.lang.String+ java.lang.String(" share ")" share " (Any)java.lang.String+ sbt.Pathpath
				Iterable[java.lang.String]s.(String)StringmkString(java.lang.String("\012\011")"\n\t")
			}
			sbt.LoadErrornew sbt.LoadErrorLoadError(java.lang.String("The same directory is used for output for multiple projects:\012\011")"The same directory is used for output for multiple projects:\n\t" (Any)java.lang.String+ StringsharedString (Any)java.lang.String+
			java.lang.String("\012  (If this is intentional, use 'override def shouldCheckOutputDirectories = false' in your project definition.)")"\n  (If this is intentional, use 'override def shouldCheckOutputDirectories = false' in your project definition.)")
		}
	}
	
	/** Writes the project name and a separator to the project's log at the info level.*/
	def (sbt.Project)UnitshowProjectHeader(sbt.Projectproject: sbt.ProjectProject)
	{
		val java.lang.StringprojectHeader = java.lang.String("Project ")"Project " (Any)java.lang.String+ sbt.Projectproject.=> Stringname
		sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("")"")
		sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.StringprojectHeader)
		sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichString"=" (Int)String* java.lang.StringprojectHeader.()Intlength)
	}
}