@Singleton
class MyFilteredJdtTypeProviderFactory extends JdtTypeProviderFactory {
	
	@Inject
	IWorkingCopyOwnerProvider copyOwnerProvider;
	
	@Inject
	TypeResourceServices typeResourceServices;

	override protected IJdtTypeProvider createJdtTypeProvider(IJavaProject javaProject, ResourceSet resourceSet) {
		if (javaProject == null){
			return new NullJdtTypeProvider(resourceSet)		
		}
		
		var WorkingCopyOwner wco= null
		if(copyOwnerProvider==null)		
			wco = DefaultWorkingCopyOwner.PRIMARY 
		else
			wco = copyOwnerProvider.getWorkingCopyOwner(javaProject, resourceSet)
		
		return new MyFilteredJdtTypeProvider(javaProject, resourceSet, getIndexedJvmTypeAccess(), wco, typeResourceServices);
	}
}

class MyFilteredJdtTypeProvider extends JdtTypeProvider {
	
	public new(IJavaProject javaProject, ResourceSet resourceSet, IndexedJvmTypeAccess indexedJvmTypeAccess, WorkingCopyOwner workingCopyOwner, TypeResourceServices services) {
		super(javaProject, resourceSet, indexedJvmTypeAccess, workingCopyOwner, services)
	}
	
	private val HashSet<String> supportedJdtTypes ={
		val hs = new HashSet()		
		hs.add("int")
		hs.add("double")
		hs.add("boolean")
		hs.add("java.lang.String")

               // Required by the compiler to process method bodys right 
                hs.add("void") 

		// Required, otherwise operators do not work
		hs.add("org.eclipse.xtext.xbase.lib.StringExtensions")
		hs.add("org.eclipse.xtext.xbase.lib.IntegerExtensions")
		hs.add("org.eclipse.xtext.xbase.lib.DoubleExtensions")
		hs.add("org.eclipse.xtext.xbase.lib.BooleanExtensions")		
		return hs
	}
		
	public override JvmType findTypeByName(String name) {
		if(name.isTypeSupported){
			return doFindTypeByName(name, false)			
		}else{
			return null
		}
	}
	
	public override JvmType findTypeByName(String name, boolean binaryNestedTypeDelimiter) {
		if(name.isTypeSupported){			
			return super.findTypeByName(name,binaryNestedTypeDelimiter)	
		}else{
			return null
		}
	}
	
	def isTypeSupported(String name){
		supportedJdtTypes.contains(name)	
	}
}

	override Class<? extends IJvmTypeProvider.Factory> bindIJvmTypeProvider$Factory() {
		return MyFilteredJdtTypeProviderFactory;
	}

class MyDslProposalProvider extends AbstractExpressionsProposalProvider {
    override protected completeJavaTypes(ContentAssistContext context, EReference reference, boolean forced,IValueConverter<String> valueConverter, ITypesProposalProvider.Filter filter,ICompletionProposalAcceptor acceptor) {		
		val extendedFilter = TypeMatchFilters.and(filter,new SupportedTypesFilter())	
		super.completeJavaTypes(context, reference, forced, valueConverter, extendedFilter, acceptor)
	}
          	 
	private static class SupportedTypesFilter extends AbstractFilter {
		override boolean accept(int modifiers, char[] packageName, char[] simpleTypeName,char[][] enclosingTypeNames, String path) {			
			// Add further predicates to filter for java types here
			packageName.join.equals("java.lang")&& simpleTypeName.join.equals("String")						
		}
	}
}