ReferenceExpression returns IExpression:
    {ReferenceExpression}
    reference=[ecore::EObject|QualifiedName]
;
 
Constant:
	name = ID '=' assignment = Expression ';'
;

Type:
	'type' name = ID 
			('extends' superType = [Type|QualifiedName])? '{'
		elements += TypeMember*
	'}'
;

TypeMember:
    Constant | TypeDeclarationVariable
;

TypeDeclarationVariable:
	dataType = VariableType name = ID';'
;

VariableType:
	type = DataType ('[' size = Expression ']')?
;

 
  public IScope scope_ReferenceExpression_reference(Constant constant, EReference reference) {
    List<EClassifier> allConstants = new ArrayList<EClassifier>();
    // what to place here?
    return Scopes.scopeFor(allConstants);
  }
  
  public IScope scope_ReferenceExpression_reference(Type type, EReference reference) {
    List<EClassifier> allConstantsAndLocalVariables = new ArrayList<EClassifier>();
    // what to place here?
    return Scopes.scopeFor(allConstantsAndLocalVariables);
  }

  public IScope scope_ReferenceExpression_reference(Constant constant,
      EReference reference) {

    AbstractScope baseScope = (AbstractScope) delegateGetScope(constant,
        reference);

    Iterable<Constant> constants = Iterables.filter(baseScope.getAllElements(),
        Constant.class);

    return Scopes.scopeFor(constants, baseScope.getParent());
  }

module Base;

type BaseType {}

module Base;
// wierd stuff is allowed:
type SubType extends Base.BaseType {} 

module Base;
type BaseType {}

module Base;
type NewBase {}
type BaseType extends NewBase {} // [1]
type Test1 extends Base.BaseType {} // [2]
type Test2 extends BaseType {} // [3]

 
module Other;
type BaseType {}
type Test3 extends Base.Test2 {} // [4]

module Base;
type BaseType {}

module Base;
type BaseType {}

module Base;

import "base2.dsl"::Base;

type BaseType {}

module Base;

import "base2.dsl"::Base;

type BaseType {}

@Inject
private IQualifiedNameProvider fqnProvider;

@Inject
private IResourceDescriptions resourceDescriptions;

  private void checkForDuplicates(EObject object, EStructuralFeature reference) {
    EObject parent = object.eContainer();
    // only check root duplicates. if root duplicates are prevented
    // nested declarations are impossible
    if (parent == null || !(parent instanceof Model)) {
      return;
    }

    QualifiedName fqn = fqnProvider.getFullyQualifiedName(object);
    URI currentResourceUri = object.eResource().getURI();

    boolean errorMarked = false;
    for (IResourceDescription resource : resourceDescriptions
        .getAllResourceDescriptions()) {

      if (!resource.getURI().equals(currentResourceUri)) { 
        Iterable<IEObjectDescription> duplicates = resource.getExportedObjects(
            MyDslPackage.eINSTANCE.getDeclaration(), fqn, false);

        if (duplicates.iterator().hasNext()) {
          if (!errorMarked) {
            error(String.format("Duplicate Declaration '%s'", nameResolver.apply(object)),
                reference);
            errorMarked = true;
          }

          // TODO: Validation on other resource
        }
      }
    }
  }

@Inject
private IResourceScopeCache cache = new IResourceScopeCache.NullImpl();

@Inject
private IQualifiedNameProvider fqnProvider;

@Inject
private IScopeProvider scopeProvider;

private void checkForDuplicates(EObject object, EStructuralFeature errorFeature) {
    EObject parent = object.eContainer();
    // only check root duplicates, if we prevent root duplicates
    // nested type-duplicates are impossible 
    if (parent == null || !(parent instanceof Model)) {
      return;
    }

    final Model model = (Model) parent;

    // Build up a map which stores all URIs for a specific QualifiedName
    // Store the map within a cache for large files 
    Map<QualifiedName, Set<URI>> duplicates = cache.get("duplicates", model.eResource(),
        new Provider<Map<QualifiedName, Set<URI>>>() {
          @Override
          public Map<QualifiedName, Set<URI>> get() {
            
            Map<QualifiedName, Set<URI>> duplicates = new HashMap<QualifiedName, Set<URI>>();

            // get the scope for any EObject reference
            // replace REFERENCE_EXPRESSION__REFERENCE with
            // any EReference which allows all EObject references 
            // mine is: ReferenceExpression: reference = [ecore::EObject|FQN];
            AbstractScope scope = (AbstractScope) scopeProvider.getScope(model,
                MyDslPackage.Literals.REFERENCE_EXPRESSION__REFERENCE);

            // walk up all parent scopes because scopes are shadowing
            // duplicate QualifiedNames
            while (scope != null) {
              // receive all elements available in this scope  
              Iterable<IEObjectDescription> elements = scope.getAllElements();
              for (IEObjectDescription element : elements) {
              
                // Create a new HashSet for the QualifiedName if needed
                QualifiedName qn = element.getName();
                if(!duplicates.containsKey(qn)) {
                  duplicates.put(qn, new HashSet<URI>());
                }
                
                // Add the new ObjectURi to the list
                duplicates.get(qn).add(element.getEObjectURI());
              }

              // Find the parent scope
              if (scope.getParent() instanceof AbstractScope) {
                scope = (AbstractScope) scope.getParent();
              }
              else {
                scope = null;
              }
            }
            return duplicates;
          }
        });
        
    // Now we can simply access all URIs of a qualified name
    final QualifiedName fqn = fqnProvider.getFullyQualifiedName(object);
    if (duplicates.get(fqn).size() > 1) {
      error(String.format("Duplicate symbol '%s'", nameResolver.apply(object)),
          errorFeature);
    } 
}

// Usage:
@Check
public void checkDuplicateDeclarations(Constant constant) {
    checkForDuplicates(constant, MyDslPackage.Literals.CONSTANT__NAME);
}