public IScope getScope( Resource resource, EReference reference, Predicate<IEObjectDescription> filter )
   {
      EClass referenceType = getEReferenceType( resource, reference );
      if( EcoreUtil2.isAssignableFrom( CommonPackage.Literals.IDENTIFIABLE_ELEMENT, referenceType ) )
      {
         return new SimpleScope( IScope.NULLSCOPE, FunctionsHolder.DESCRIPTIONS );
      }
      return super.getScope( resource, reference, filter );
   }

      Function myFirstFunction = globalFactory.createFunction();
      myFirstFunction.setName( "helloWorld" );
      myFirstFunction.setType( commonFactory.createStringType() );
      ...
      DESCRIPTIONS.add( EObjectDescription.create( "helloWorld", myFirstFunction ) );

public class GlobalQualifiedNameProvider extends DefaultDeclarativeQualifiedNameProvider
{
   @Inject
   private IQualifiedNameConverter converter = new IQualifiedNameConverter.DefaultImpl();

   public QualifiedName qualifiedName( Function function )
   {
      StringBuilder builder = new StringBuilder();
      builder.append( function.getName() );
      builder.append( '.' );
      Iterator<Parameter> iterator = function.getParameters().iterator();
      while( iterator.hasNext() )
      {
         Parameter next = iterator.next();
         builder.append( getType( next.getType() ) );
         if( next.isMultiple() )
         {
            builder.append( "[]" );
         }
      }
      String result = builder.toString();
      QualifiedName qualifiedName = converter.toQualifiedName( result );
      return qualifiedName;
   }

   private String getType( DataType dataType )
   {
      if( dataType instanceof BoolType )
      {
         return "boolean";
      }...

public class MyValueConverterService extends DefaultTerminalConverters
{
   @Inject
   private AbstractIDValueConverter idValueConverter;

   public class FeatureCallValueConverter implements IValueConverter<String>
   {
      @Override
      public String toValue( String string, INode node ) throws ValueConverterException
      {
         return idValueConverter.toValue( string, node );
      }

      @Override
      public String toString( String value ) throws ValueConverterException
      {
         if( value.contains( "." ) )
         {
            String[] split = value.split( "\\." );
            return split[0] + "()";
         }
         return value;
      }
   }

   private FeatureCallValueConverter valueConverter = new FeatureCallValueConverter();

   @Override
   public IValueConverter<String> ID()
   {
      return valueConverter;
   }
}

public class MyLinkingService extends DefaultLinkingService
{
   @Override
   public List<EObject> getLinkedObjects( EObject context, EReference ref, INode node ) throws IllegalNodeException
   {
      List<EObject> linkedObjects = super.getLinkedObjects( context, ref, node );
      if( linkedObjects.isEmpty() && context instanceof FeatureCall
         && ( (FeatureCall) context ).isExplicitFunctionCall() )
      {
         IScope scope = getScope( context, ref );
         Iterable<IEObjectDescription> allElements = scope.getAllElements();
         // find the best matching function based on name and parameters and the parameters type
         EObject result = bestMatch( (FeatureCall) context, allElements, node );
         if( result != null )
         {
            return Lists.newArrayList( result );
         }
      }
      return linkedObjects;
   }
...