Model:
  Foo | Symbol | Container;

Foo: "foo" name=ID;

// this container has "Foo" containment references
Container: 
"container" "{"
    elements+=(Foo|Symbol)*
"}";

// this container has "Foo" non-containment references
NonContainer:
"non-container" "{"
  elements+=[Foo]
"};

// this construct has exactly one "Foo" non-containment reference
Symbol: "@" ref=[Foo];

static val factory = MyDslFactory.eINSTANCE

def someFunc(Container victim) {

  // assert that victim only holds Foo containment references (no "Symbol") -- just for demonstration purposes

  val thief = factory.createContainer => [
    elements+=victim.elements
  ]
  // now "thief" owns all containment-refs of "victim" => victim.elements.empty == true

  val copycat = factory.createContainer => [
    elements+= victim.elements.map[e | EcoreUtil2.copy(e)]
  ]
  // now "copycat" has (deep?)-copys of all containment references of "victim", so victim stays unchanged

  val delegator = factory.createContainer => [
    elements+= victim.elements.map[e | factory.createSymbol => [ref=e] ]
  ]
  // now "delegator" has symbols to all of "victims" elements => "victim" also stays unchanged
}

  public NotificationChain eBasicSetContainer(InternalEObject newContainer, int newContainerFeatureID, NotificationChain msgs)
  {
    InternalEObject oldContainer = eInternalContainer();
    Resource.Internal oldResource = this.eDirectResource();

@Singleton
class StealingAdapter extends AdapterImpl {

	Map<Object, Object> stolenObjects = newHashMap
	
	override notifyChanged(Notification notification) {
		switch (notification.eventType) {
			case Notification.REMOVE: containerRemove(notification.notifier, notification.oldValue)
			case Notification.ADD: containerAdd(notification.notifier, notification.newValue)
		}
	}
	
	def containerAdd(Object potentialThief, Object wallet) {
		val maybeVictim = Optional.ofNullable(stolenObjects.get(wallet))
		
		if (maybeVictim.present) {
			throw new IllegalStateException('''«wallet» was stolen from «maybeVictim.get»''')
		}
	}
	
	def containerRemove(Object potentialVictim, Object wallet) {
		this.stolenObjects.put(wallet, potentialVictim)	
	}
}

class MyDslEcoreElementFactory extends DefaultEcoreElementFactory {
	
	@Inject MyDslStealingAdapter adapter
	
	override EObject create(EClassifier classifier) {
		val eobj = super.create(classifier)

		eobj.eAdapters().add(adapter)	
		eobj
	}
}

public class MyDslAdapterAddingFactory extends MyDslSwitch<EObject> implements MyDslFactory {

	@Inject MyDslStealingAdapter adapter;
	private MyDslFactory delegate;

	
	public MyDslAdapterAddingFactory(MyDslFactory delegate) {
		this.delegate = delegate;
	}

	@Override
	public EObject defaultCase(EObject obj) {
		// final MyDslStealingAdapter adapter = adapterProvider.get();
		obj.eAdapters().add(adapter);
		return obj;
	}
	
	@SuppressWarnings("unchecked")
	public <T extends EObject> T adapt(T obj) {
		return (T) doSwitch(obj);
	}


	public Model createModel() {
		return adapt(delegate.createModel());
	}

	public createFoo createFoo() {
		return adapt(delegate.createFoo());
	}

    // ... rest of the overriden methods 

}

class MyDslRuntimeModule extends AbstractMyDslRuntimeModule {

	def MyDslFactory bindMyDslFactory() {
		val factory = MyDslFactory.eINSTANCE
		return new MyDslAdapterAddingFactory(factory)
	}	

	override Class<? extends IAstFactory> bindIAstFactory() {
		return MyDslEcoreElementFactory
	}

    // ...
}

emfGenerator {
  rootExtendsClass = "org.example.mydsl.MyDslEObjectImpl"
}

class MyDslEObjectImpl extends MinimalEObjectImpl.Container {

	override NotificationChain eBasicSetContainer(InternalEObject newContainer, int newContainerFeatureID,
		NotificationChain msgs) {

		val oldContainer = eInternalContainer();
		
		if (oldContainer !== null && newContainer !== null) {
			throw new IllegalStateException('''«newContainer» attempts to steal «this» from «oldContainer»''')
		}
		
		super.eBasicSetContainer(newContainer, newContainerFeatureID, msgs)
	}
}