JavaEmbeddedRecord.java

class JavaEmbeddedRecord<UserId extends Long> {
    public UserId getId() {
       return (UserId)(new Long(5));
    }
}

JavaMetaEmbeddedRecord.java

abstract public class JavaMetaEmbeddedRecord<R extends JavaEmbeddedRecord<? extends Long>> {
    abstract public R createRecord();
}

JavaMetaRecord.java

import java.util.ArrayList;
import scala.collection.JavaConversions;
import scala.collection.Seq;
import scala.collection.immutable.Map;
import scala.Option;
import scala.Some;

abstract public class JavaMetaRecord<
        R extends Record<R>,
        M extends MetaRecord<R>,
        VenueId extends ObjectId>
    implements MetaRecord<R> {

    public JavaMetaRecord() {
        _id = new IdFieldDescriptor();
        ArrayList<FieldDescriptor<?, R, MetaRecord<R>>> list = new ArrayList<FieldDescriptor<?, R, MetaRecord<R>>>();
        list.add((FieldDescriptor<?, R, MetaRecord<R>>)_id);
        _fields = JavaConversions.asScalaBuffer(list).toList();
    }

    abstract public R createRecord();
    abstract public MutableRecord<R> createRawRecord();
    public scala.Option<R> ifInstanceFrom(Object a) { return null; }

    class IdFieldDescriptor implements FieldDescriptor<VenueId, R, M> {
        public M owner() { return (M)JavaMetaRecord.this; }
        public int id() { return 1; }
        public String longName() { return "id"; }
        public Map<String, String> annotations() { return null; }
        public Option<VenueId> getter(R r) { return new Some(((JavaRecord)r).getId()); }
        public Option<VenueId> getterOption(R r) { return getter(r); }
        public void setterRaw(MutableRecord<R> r, VenueId f) { ((JavaRecord)r).setId(f); }
        public void unsetterRaw(MutableRecord<R> r) { setterRaw(r, null); }
        public Option<Object> unsafeGetterOption(Object obj) { return new Some(((JavaRecord)obj).getId()); }
    }

    private IdFieldDescriptor _id = null;
    public FieldDescriptor<VenueId, R, M> id() {
        return _id;
    }

    private Seq<FieldDescriptor<?, R, MetaRecord<R>>> _fields = null;
    public Seq<FieldDescriptor<?, R, MetaRecord<R>>> fields() {
        return _fields;
    }
}

JavaRecord.java

public abstract class JavaRecord<
        R extends Record<R>,
        M extends MetaRecord<R>,
        VenueId extends ObjectId,
        Embedded extends JavaEmbeddedRecord<? extends Long>>
    implements Record<R>, MutableRecord<R> {

    abstract public M meta();

    public R mergeCopy(R that) { return that; }

    public void merge(R that) {}

    private VenueId _id = null;
    public VenueId getId() {
       return _id;
    }
    public void setId(VenueId id) {
        _id = id;
    }

    private Embedded struct = null;
    public Embedded getStruct() {
        return struct;
    }
    public void setStruct(Embedded e) {
        struct = e;
    }

    abstract protected JavaMetaEmbeddedRecord<Embedded> getEmbeddedMeta();
}

ObjectId.java

public class ObjectId {}

Record.scala

trait Record[R <: Record[R]] { self: R =>
  def meta: MetaRecord[R]
  def mergeCopy(that: R): R
}

trait FieldDescriptor[F, R <: Record[R], M <: MetaRecord[R]] {
  def owner: M
  def id: Int
  def longName: String
  def annotations: Map[String, String]
  def getter(r: R): Option[F]
  def getterOption(r: R): Option[F] = getter(r)
  def setterRaw(r: MutableRecord[R], f: F): Unit
  def unsetterRaw(r: MutableRecord[R]): Unit
  def unsafeGetterOption(a: Any): Option[Any] = getterOption(a.asInstanceOf[R])
}

trait MetaRecord[R <: Record[R]] {
  def createRecord: R
  def createRawRecord: MutableRecord[R]
  def fields: Seq[FieldDescriptor[_, R, MetaRecord[R]]]
  def ifInstanceFrom(x: AnyRef): Option[R]
}

trait MutableRecord[R] { self: R =>
  def merge(that: R): Unit
}

run

#!/bin/sh

OUT=out/
rm -rf $OUT
mkdir $OUT

CP=$OUT:/Users/jliszka/.ivy2/cache/org.scala-lang/scala-library/jars/scala-library-2.11.2.jar

scalac -cp $CP -d $OUT Record.scala && \
javac -cp $CP -d $OUT *.java && \
scalac -cp $CP -d $OUT ScalaRecord.scala && \
scala -cp $CP

ScalaRecord.scala

trait Tagged[T]

object Ids {
  type Id[A, B] = A with Tagged[B]
  trait VenueIdTag
  type VenueId = Id[ObjectId, VenueIdTag]
  def VenueId(id: ObjectId): VenueId = id.asInstanceOf[VenueId]

  trait UserIdTag
  type UserId = Id[java.lang.Long, UserIdTag]
}

import Ids.{UserId, VenueId}

class ScalaRecord extends JavaRecord[ScalaRecord, ScalaMetaRecord, VenueId, EmbeddedRecord] {
  override def meta: ScalaMetaRecord = ScalaRecord
  protected override def getEmbeddedMeta(): JavaMetaEmbeddedRecord[EmbeddedRecord] = EmbeddedRecord
}
class ScalaMetaRecord extends JavaMetaRecord[ScalaRecord, ScalaMetaRecord, VenueId] {
  override def createRecord: ScalaRecord = new ScalaRecord
  override def createRawRecord: ScalaRecord = new ScalaRecord
}
object ScalaRecord extends ScalaMetaRecord


class EmbeddedRecord extends JavaEmbeddedRecord[UserId]
object EmbeddedRecord extends JavaMetaEmbeddedRecord[EmbeddedRecord] {
  override def createRecord: EmbeddedRecord = new EmbeddedRecord
}


/*

val r = ScalaRecord.createRecord
val r = ScalaRecord.createRawRecord
val e = EmbeddedRecord.createRecord
def id = Ids.VenueId(new ObjectId)
r.setId(id)
r.getId
r.setStruct(e)
r.getStruct
r.getStruct.getId
r.meta
r.meta.createRawRecord.merge(r)
r.meta.id
r.meta.id.owner
r.meta.fields

r.meta.id.getter(r)
r.meta.id.setterRaw(r, id)
r.getId

*/