A commit which breaks the compiler

Author: noresttherein

build.sbt

@@ -33,8 +33,7 @@ libraryDependencies ++= Seq(
 
 scalacOptions ++= Seq(
 //	"-Ylog-classpath",
-//	"-Xlog-implicits",
-	"-explaintypes",
+	"-Xlog-implicits",
 	"-Wconf:cat=deprecation&msg=foldLeft:silent,cat=deprecation&msg=foldRight:silent,cat=deprecation:w,cat=feature:w",
 	"-language:implicitConversions",
 	"-language:higherKinds",

src/main/scala/net/noresttherein/oldsql/OperationType.scala

@@ -37,7 +37,7 @@ sealed trait OperationType {
 	val nonDefault :FlagBuffType
 
 	/** A buff marking that a column/component must be included in the operation explicitly, as it is not included
-	  * by the mapping in the standard process. Example: `ExplicitSelect` for CLOB/BLOB types. This column implies
+	  * by the mapping in the standard process. Example: `ExplicitSelect` for CLOB/BLOB types. This buff implies
 	  * [[net.noresttherein.oldsql.OperationType.optional optional]] and
 	  * [[net.noresttherein.oldsql.OperationType.nonDefault nonDefault]].
 	  */

src/main/scala/net/noresttherein/oldsql/hoard/Pile.scala

@@ -30,7 +30,9 @@ trait Pile[T] { pile =>
 			case e :Exception => try {
 				session.close()
 				throw e
-			} finally {throw e }
+			} catch {
+				case e1 :Throwable => e.addSuppressed(e1); throw e
+			}
 		}
 	}
 

src/main/scala/net/noresttherein/oldsql/model/ComposedOf.scala

@@ -6,7 +6,9 @@ import net.noresttherein.oldsql.model.ComposedOf.{Arity, ComposableFrom, Decompo
 import net.noresttherein.oldsql.model.ComposedOf.ComposableFrom.{Collection, Custom}
 import net.noresttherein.oldsql.slang._
 
-//todo: implicits for immutable.Iterable and immutable.Map
+
+
+
 
 
 
@@ -171,7 +173,7 @@ object ComposedOf {
 
 
 	/** An implicit witness that type `C` is strictly composed of a variable or multiple number of values of type `E`.
-	  * This particularly excludes instances of `C ComposedOf E` so that operations which either make no sense or can
+	  * This particularly excludes instances of `E ComposedOf E` so that operations which either make no sense or can
 	  * be misleading when dealing with singleton values can require a `C CollectionOf E` instead of the more generic
 	  * `C ComposedOf E`.
 	  */

src/main/scala/net/noresttherein/oldsql/model/InvocationReflection.scala

@@ -157,7 +157,7 @@ private[model] object InvocationReflection {
 
 
 	private def mock(subjectType :Type) :Any = {
-		val subjectClass = classFor(subjectType) //todo: maybe it _can_ extend final classes?
+		val subjectClass = classFor(subjectType)
 		if (!subjectClass.isPrimitive && (subjectClass.getModifiers & FINAL) == 0)
 			tracer(subjectType, subjectClass)
 		else

src/main/scala/net/noresttherein/oldsql/model/Restraint.scala

@@ -25,7 +25,7 @@ import net.noresttherein.oldsql.slang._
   * treated as a result set of values of `T`, because then it would have to be covariant with regards to `T` -
   * a set of values of `S` is of course a set of values of `T>:S`. This becomes an issue when used inside a
   * `Kin[T]`, which is covariant with regards to `T` and care has to be taken when dealing with such cases.
-  */
+  */ //consider: renaming to Selection
 trait Restraint[-T] extends (T => Boolean) with scala.Equals with Serializable with implicits {
 
 	/** Creates a restraint implementing the negated condition of this restraint (i.e. selecting a value ''iff''
@@ -130,7 +130,7 @@ object Restraint {
 		def compose[K](oldKey :P=>K, newKey :K=>P) :Restrainer[T, K] =
 			new MappedRestrainer[T, P, K](this)(oldKey, newKey)
 
-		/** Create a restrainer working on some other, larger type `X` from which values of `S<:T` can be derived. */
+		/** Create a restrainer working on some other, larger type `X` from which values of `S <: T` can be derived. */
 		def derive[X, S<:T](nest :Restrictive[X, S]) :Restrainer[X, P] = new NestedRestrainer(this, nest)
 
 		def canEqual(that :Any) :Boolean = that.isInstanceOf[Restrainer[_, _]]
@@ -735,7 +735,8 @@ object Restraint {
 
 
 		/** Check if the given restriction is a membership test for a set. */
-		def unapply[T](restraint :Restraint[T]) :Option[(Restrictive[T, E], Restrictive[T, C], C DecomposableTo E) forSome { type E; type C }] =
+		def unapply[T](restraint :Restraint[T])
+				:Option[(Restrictive[T, E], Restrictive[T, C], C DecomposableTo E) forSome { type E; type C }] =
 			restraint match {
 				case m :MembershipTest[T, c, e] => Some((m.member, m.values, m.decomposer))
 //				case Equal(left, right) => Some((left, right, DecomposableTo.Subclass()))
@@ -771,7 +772,7 @@ object Restraint {
 					items.collect { case Literal(v) => v.asInstanceOf[K] }.toSet providing (_.size == items.size)
 
 				case Membership(Term, Literal(items), deco) =>
-					//todo: wrong! may be Iterable[Set[K]] after decomposer
+					//todo: wrong! may be Iterable[Set[K]] after decomposition
 					Some(deco.asInstanceOf[DecomposableTo[Any, Any]].apply(items).toSet.asInstanceOf[Set[K]])
 
 				case False => Some(Set.empty)

src/main/scala/net/noresttherein/oldsql/model/Restrictive.scala

@@ -23,7 +23,7 @@ import scala.reflect.runtime.universe
   * where `T` is some constrained entity. Instances of this type are typically tested with a predicate
   * or compared with other instances to produce Boolean conditions.
   * @see [[net.noresttherein.oldsql.model.Restraint.Restrainer Restrainer]]
-  */ //todo: awkward name, think of something better
+  */ //todo: awkward name, think of something better. Selector?
 sealed trait Restrictive[-T, V] extends TranslableTerm[T, V] with Serializable with implicits {
 //todo: def apply(whole :T) :V and self type to T => V. If only private classes implement T => V,
 // it will not count as an implicit conversion.

src/main/scala/net/noresttherein/oldsql/schema/ColumnMapping.scala

@@ -262,7 +262,7 @@ sealed abstract class LowPriorityColumnMappingImplicits {
 	                      (implicit subject :C <:< ColumnMapping[S, O], origin :F <:< O,
 	                       offset :TableCount[O, _ <: Numeral],
 	                       projection :OriginProjection[C, S] { type WithOrigin[A] <: ColumnMapping[S, A] })
-			:ColumnSQL[F, GlobalScope, S] =
+			:LooseColumnComponent[F, projection.WithOrigin, S] =
 		LooseColumnComponent(projection[F](column), offset.tables)
 
 }

src/main/scala/net/noresttherein/oldsql/schema/Mapping.scala

@@ -872,7 +872,7 @@ trait Mapping {
 
 	/** The SQL/DDL-related name associated with this mapping. This must be defined for all column and table
 	  * mappings, but is typically empty in all other cases.
-	  */ //consider: removing this altogether, probably once we've implemented actutal table schema
+	  */ //consider: removing this altogether, probably once we've implemented actual table schema
 	def sqlName :Option[String] = None
 
 
@@ -1730,7 +1730,7 @@ object Mapping extends LowPriorityMappingImplicits {
 					s"Can't create a $op write form for $mapping using $exports: ${op.prohibited} buff present among selection."
 				)
 
-			val columns = exports.flatMap { //fixme: adding an ExplicitXxx buff to a column with the
+			val columns = exports.flatMap { //fixme: adding an ExplicitXxx buff to excluded columns with the OptionalXxx
 				c => c.columns.toSeq.map(mapping.export(_)).filter(op.prohibited.disabled)
 			}.toUnique
 			val mandatory = mapping.columns.filter(op.nonDefault.disabled)

src/main/scala/net/noresttherein/oldsql/schema/MappingSchema.scala

@@ -64,7 +64,7 @@ trait MappingSchema[S, V <: Chain, C <: Chain, O] extends BaseMapping[V, O] with
 	override type Unpacked = V
 
 	//fixme: C might omit mandatory components! schema.forSelect(...).forUpdate(...) can exclude a component necessary
-	//  for update, but not select. We need special subclasses SelectSchema
+	//  for update, but not select. We need special subclasses SelectSchema or perhaps better, a SchemaForm.
 	override type Components = C
 
 	/** The `Subject` type of the outer mapping to which this schema belongs. */

src/main/scala/net/noresttherein/oldsql/schema/Relation.scala

@@ -97,13 +97,14 @@ object Relation {
 	  * accepting the `Origin` type for use in `FromClause` subclasses and other types accepting such a type constructor:
 	  * `Dual Join (Humans As "humans")#T` (where `Humans[O] <: MappingAt[O]`).
 	  * @see [[net.noresttherein.oldsql.schema.bits.LabeledMapping.@:]]
-	  */
+	  */ //
 	class As[M[O] <: MappingAt[O], A <: Label](val relation :Relation[M], val alias :A)
 		extends NamedRelation[A, ({ type T[O] = A @: M[O] })#T]
-	{
+	{ //todo: the contract of name/sql must be specified here; is alias a part of sql?
 		type T[O] = A @: M[O]
 
 		override def name :A = alias
+		override def sql :String = relation.sql
 
 		override def apply[O] :A @: M[O] =
 			(alias @: relation[O].asInstanceOf[RefinedMapping[Any, Any]]).asInstanceOf[A @: M[O]]

src/main/scala/net/noresttherein/oldsql/schema/bits/MappedMapping.scala

@@ -159,7 +159,7 @@ object MappedMapping {
 
 	def adapter[M <: MappingAt[O], T, S, O](mapping :MappingAdapter[M, T, O], mapped: T =?> S, unmapped :S =?> T)
 	                                       (implicit nulls :NullValue[S] = null) :M MappedTo S =
-		new MappedAdapter[M, T, S, O](mapping, mapped, unmapped)
+		new MappedAdapterAdapter[M, T, S, O](mapping, mapped, unmapped)
 
 	def mapAdapter[M <: MappingAt[O], T, S, O](mapping :MappingAdapter[M, T, O], mapped :T => S, unmapped :S => T)
 	                                          (implicit nulls :NullValue[S] = null) :M MappedTo S =
@@ -186,10 +186,10 @@ object MappedMapping {
 
 
 
-	private class MappedAdapter[+M <: MappingAt[O], T, S, O]
-	                           (protected override val backer :MappingAdapter[M, T, O],
-	                            protected override val map :T =?> S, protected override val unmap :S =?> T)
-	                           (implicit protected override val nulls :NullValue[S] = null)
+	private class MappedAdapterAdapter[+M <: MappingAt[O], T, S, O]
+	                                  (protected override val backer :MappingAdapter[M, T, O],
+	                                   protected override val map :T =?> S, protected override val unmap :S =?> T)
+	                                  (implicit protected override val nulls :NullValue[S] = null)
 		extends MappedMapping[T, S, O] with ComposedAdapter[M, T, S, O]
 	{
 		override def as[X](there :S =?> X, back :X =?> S)(implicit nulls :NullValue[X]) :MappingAdapter[M, X, O] =