namespace Root {
...
}

<othernames>
// continue Root:
namespace Root {
..
}

public Class<? extends IQualifiedNameConverter> bindIQualifiedNameConverter() {
		return QualifiedNameConverter.class;
	}
	
	@Override
	public void configureIScopeProviderDelegate(Binder binder) {		
		binder.bind(org.eclipse.xtext.scoping.IScopeProvider.class)
		.annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider.NAMED_DELEGATE))
		.to(FOImportedNamespaceAwareLocalScopeProvider.class);
	}
        
	@Override
	public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() {		
		return ImportUriGlobalScopeProvider.class;
	}

// scoping and exporting API
            //fragment = scoping.ImportURIScopingFragment {}
            // fragment = exporting.SimpleNamesFragment {}

            // scoping and exporting API
            fragment = scoping.ImportNamespacesScopingFragment {}

namespace Root {
  namespace A {
    elements of A...
  }

namespace Root {
  namespace B {
    using namespace A // not working, it works if Root::A is written, it works with just QFN "A" if this code is in the same file as namespace A
    elements of B using elements of A
  }

#include "fileA"

namespace Root {
  namespace B {
    using namespace A // not working, it works if Root::A is written, it works with just QFN "A" if this code is in the same file as namespace A
    elements of B using elements of A
  }

Root:
	importedFiles+=IncludeFile*
	contents+=Idp*
;

Idp:  	
	Using	 
	| Namespace 
	| Vocabulary 
	| Theory
	| Instruction				
;

IncludeFile:
	'#include' importURI=STRING 
;

Namespace: 
	'namespace' name=ID 
	'{' contents+=Idp* '}'
;

Using: 
	'using' (UsingVocabulary|UsingNamespace)
;

UsingVocabulary:
	'vocabulary' importedNamespace=FQN
;

UsingNamespace:
	'namespace' importedNamespace=FQN
;

Model:
	includes+=IncludeFile*
	elements+=Namespace*;
	
IncludeFile:
	'#include' importedNamespace=FQN
;	
	
AbstactElement:
	Element | Namespace | Import
;

Import:
	"using" importedNamespace=FQN
;

Namespace:
	"namespace" name=ID "{"
		elements+=AbstactElement*
	"}"
;

Element:
	"element" name=ID ("uses" uses=[Element|FQN])?
;

FQN: ID ("." ID)*;

public class MyDslQualifiedNameProvider extends
		DefaultDeclarativeQualifiedNameProvider {
	
	QualifiedName qualifiedName(Model m) {
		String name = m.eResource().getURI().trimFileExtension().lastSegment();
		return QualifiedName.create(name);
	}

}

public class MyDslImportedNamespaceAwareLocalScopeProvider extends
		ImportedNamespaceAwareLocalScopeProvider {
	
	protected List<ImportNormalizer> internalGetImportedNamespaceResolvers(final EObject context, boolean ignoreCase) {
		List<ImportNormalizer> importedNamespaceResolvers = Lists.newArrayList();
		SimpleAttributeResolver<EObject, String> importResolver = SimpleAttributeResolver.newResolver(String.class,
				"importedNamespace");
		EList<EObject> eContents = context.eContents();
		for (EObject child : eContents) {
			String value = importResolver.getValue(child);
			ImportNormalizer resolver = createImportedNamespaceResolver(value+".*", ignoreCase);
			if (resolver != null)
				importedNamespaceResolvers.add(resolver);
			
		}
		if (context instanceof Namespace) {
			ImportNormalizer resolver2 = createImportedNamespaceResolver(((Namespace)context).getName()+".*", ignoreCase);
			if (resolver2 != null) {
				importedNamespaceResolvers.add(resolver2);
			}
		}
		return importedNamespaceResolvers;
	}

}

public class MyDslRuntimeModule extends
		org.xtext.example.mydsl.AbstractMyDslRuntimeModule {

	@Override
	public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() {
		return MyDslQualifiedNameProvider.class;
	}

	public void configureIScopeProviderDelegate(com.google.inject.Binder binder) {
		binder.bind(IScopeProvider.class)
				.annotatedWith(
						Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE))
				.to(MyDslImportedNamespaceAwareLocalScopeProvider.class);
	}

}