what is magic of Scala Array.apply

From array.scala of scala-2.10.4, The Array is defined as

final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable {    
  /** The length of the array */
  def length: Int = throw new Error()
  def apply(i: Int): T = throw new Error()
  def update(i: Int, x: T) { throw new Error() }
  override def clone(): Array[T] = throw new Error()
}

Please note, the apply method will throw an exception! And for the accompany object Arrry, I find the following codes:

  def apply[T: ClassTag](xs: T*): Array[T] = {
    val array = new Array[T](xs.length)
    var i = 0
    for (x <- xs.iterator) { array(i) = x; i += 1 }
    array
  }

I know there is an implicit parameter which is ClassTag[T], what make me surprised is how

new Array[T] (xs.length)

is compiled. By decompiling the Array.class, I find that line is translated to :

public <T> Object apply(Seq<T> xs, ClassTag<T> evidence$2)
{
    // evidence$2 is implicit parameter
    Object array = evidence$2.newArray(xs.length());
    ...  
}

I am really confused by this kind of translation, what is the rule under the hood?

Thanks Chang