private IScope getScopeWithLibrary(Resource resource, EReference reference) {
		if (resourceDescriptionData == null) {
			synchronized (semaphore) {
				ResourceSet resourceSet = resourceSetProvider.get();
				URI uri = URI.createURI("classpath:/stdlib.stext");
				Resource stdlib = resourceSet.getResource(uri, true);
				IResourceDescription stdlibDescription = descriptionManager.getResourceDescription(stdlib);
				
				resourceDescriptionData = new ResourceDescriptionsData(Collections.singletonList(stdlibDescription));
			}
		}
		return SelectableBasedScope.createScope(super.getScope(resource, reference, null), resourceDescriptionData, reference.getEReferenceType(), false);
	}

	def void testSerialization1() {
		StructuredTextFactoryImpl.init
		val model = createStructuredTextModel => [
			function = createFunctionBlock => [
				name = "F1"
				inputs = createInputsList => [
					items += createVarDeclarationInit => [
						typeName = Type_Name.NUMERIC

						variables += createPrimaryVariable => [
							name = "X"
						]
					]
				]
				outputs = createOutputsList => [
					items += createVarDeclarationInit => [
						typeName = Type_Name.BOOL
						variables += createPrimaryVariable => [
							name = "Y"
						]
					]
				]
				val var_X = inputs.items.map[variables].flatten.head
				val var_Y = outputs.items.map[variables].flatten.head
				statements += createAssignmentStatement => [
					variables += var_Y
					expression = createCall => [
						func = createIntrinsicFunction => [
							name = "COS"
						]
						args += createVariableReference => [
							variable = var_X
						]
					]
				]
			]
		]
		val resourceSet = resourceSetProvider.get
		val resource = resourceSet.createResource(URI.createURI("dummy.stext"))
		resource.contents += model

		val actual = resource.contents.head.serialize(SaveOptions.newBuilder().format.options)

}

java.lang.RuntimeException: No EObjectDescription could be found in Scope Call.func for IntrinsicFunction'COS'
Semantic Object: StructuredTextModel.function->FunctionBlock'F1'.statements[0]->AssignmentStatement.expression->Call
URI: dummy.stext
EStructuralFeature: structuredText::Call.func

class StructuredTextResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {
	@Inject StructuredTextPackage pck

	override boolean createEObjectDescriptions(EObject object, IAcceptor<IEObjectDescription> acceptor) {
		switch (object.eClass) {
			case pck.structuredTextModel : { return true }
			case pck.intrinsicFunction : { 
				super.createEObjectDescriptions(object, acceptor)
				return false
			}
			case pck.functionBlock : { 
				super.createEObjectDescriptions(object, acceptor)
				return true
			}
			case pck.varDeclarationInit: {
				if (object.eContainer instanceof InputsList) {
					super.createEObjectDescriptions(object, acceptor)
					return true
				} else {
					return false
				}
			}
			case pck.unit : { 
				super.createEObjectDescriptions(object, acceptor)
				return false
			}
			default: return true
		}
	}
}

Func_Call returns Call:
	func=[IntrinsicFunction] //Allow only our supported intrinsic functions
	'(' (args += Expression (',' args += Expression)*)? ')'
;

Intr_Function returns IntrinsicFunction:
	{IntrinsicFunction}
	name=ID 
	'(' (args += Intr_Function_Arg (',' args += Intr_Function_Arg)*)? ')'
	(':' returnType=Type_Name)?
	';'
;

@Inject StructuredTextScopeProvider scopeProvider
...
...
func = block.globalScope.intrinsicFunctions.filter[f|f.name == node.operatorType.toString].head

def IScope globalScope(FunctionBlock block) {
		scopeProvider.delegate.getScope(block.eContainer, StructuredTextPackage.Literals.CALL__FUNC)
	}

def List<IntrinsicFunction> intrinsicFunctions(IScope scope) {
	Lists.transform(
		scope.allElements.filter[o|o.EObjectOrProxy instanceof IntrinsicFunction].map[EObjectOrProxy].toList,
		eObjectToIntrinsicFunction
		)
	}