IEObjectDescription singleElement = globalScope.getSingleElement(qualifiedName);
		
if (singleElement != null && singleElement.getEClass().equals(eClass))
{
	Enum resolve = (Enum) EcoreUtil2.resolve(singleElement.getEObjectOrProxy(), res);
	EList<EnumConstructor> constructors = resolve.getConstructors();
			
	for (EnumConstructor constructor : constructors)
	{
		implicitImports.add(new ImportNormalizer(qualifiedName.append(constructor.getName()), false, ignoreCase));
	}
}

Import:
	'import' importedNamespace=QualifiedNameWithWildcard ';';

protected List<ImportNormalizer> getImplicitImports(boolean ignoreCase, IScope globalScope, Resource res) {
	List<ImportNormalizer> implicitImports = super.getImplicitImports(ignoreCase);
	implicitImports = Lists.newArrayList(implicitImports);
	implicitImports.add(
			new ImportNormalizer(
					QualifiedName.create("package.Type"), 
					false, 
					ignoreCase
			)
	);
}

enum Bool {
	true;
	false;
}

implicitImports.add(new ImportNormalizer(QualifiedName.create("Bool"), false, ignoreCase));

class X
{
	function y() : Bool {
        	return true;
	}
}

enum Bool2 {
	true;
	false;
        null;
}

return true;

enum Color2 {
        red;
        green;
        blue;
        grey( v : Int );
        rgb( r : Int, g : Int, b : Int );
}

public class MyDslImportedNamespaceAwareLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider {
	
	@Override
	protected List<ImportNormalizer> internalGetImportedNamespaceResolvers(
			EObject context, boolean ignoreCase) {
		List<ImportNormalizer> result = super.internalGetImportedNamespaceResolvers(context, ignoreCase);
		if (context instanceof Function) {
			Function function = (Function) context;
			String value = NodeModelUtils.findNodesForFeature(function, MyDslPackage.Literals.FUNCTION__RETURN_TYPE).get(0).getText();
			ImportNormalizer resolver = createImportedNamespaceResolver(value+".*", ignoreCase);
			if (resolver != null)
				result.add(resolver);
		}
		return result;
	}

}

Model:
	elements+=Element*;
	
Element:
	Enum | Class
;

Enum:
	"enum" name=ID "{"
		literals+=Literal*
	"}"
;

Literal:
	name=ID ";"
;

Class:
	"class" name=ID "{"
		functions+=Function*
	"}"
;

Function:
	"function" name=ID "()" ":" returnType=[Enum] "{"
        	statements+=Statement*
	"}"
;

Statement:
	"return" ref=[Literal] ";"
;

public class MyDslScopeProvider extends AbstractDeclarativeScopeProvider {

	IScope scope_Statement_ref(Function f, EReference ref) {
		return Scopes.scopeFor(f.getReturnType().getLiterals());
	}
	
}

import my.package.Color;

class X
{
   function y(a)
   {
      //red, blue and green are the literals defined in the Color enum 
      switch (a)
      {
         case red: return 1;
         case blue: return 2;
         case green: return 3;
      }
   }
}

Enum:
	metadata=Metadata?
	extern='extern'? visibility=Visibility? 'enum' name=ValidID typeParameters=TypeParameters?
	'{'
		(constructors+=EnumConstructor)*
	'}';

EnumConstructor:
	metadata=Metadata?
	name=ValidID ('(' parameters+=OptionalParameter (',' parameters+=OptionalParameter)* ')')? ';'?;

	protected ImportScope createImportScope(IScope parent, List<ImportNormalizer> namespaceResolvers, ISelectable importFrom, EClass type, boolean ignoreCase) {
		
		List<ImportNormalizer> newNamespaceResolvers = namespaceResolvers;
		
		if (isFeature(type)) {
			newNamespaceResolvers = Lists.newArrayList(namespaceResolvers);
			
			try {
				importedNamespacePrefixField.setAccessible(true);
				
				for (ImportNormalizer namespaceResolver : namespaceResolvers) {
					QualifiedName qn = (QualifiedName) importedNamespacePrefixField.get(namespaceResolver);
					
					IEObjectDescription singleElement = parent.getSingleElement(qn);
					
					if (singleElement != null && isEnum(singleElement)) {
						newNamespaceResolvers.add(new ImportNormalizer(qn, true, ignoreCase));
					}
				}
				
				importedNamespacePrefixField.setAccessible(false);
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		
		return super.createImportScope(parent, newNamespaceResolvers, importFrom, type, ignoreCase);
	}