use signature as type for template definition

	EXTKEYWORD CONSTKEYWORD type=Type id=IdentifierList;

ImportDef:

	IMPORTKEYWORD ImportFromSpec (all=AllWithExcepts | LBRACKET importSpec=ImportSpec RBRACKET);

	IMPORTKEYWORD importFrom=ImportFromSpec (all=AllWithExcepts | LBRACKET importSpec=ImportSpec RBRACKET);

	// TODO: fix import

ImportFromSpec:

	guard=InterleavedGuard statement=StatementBlock;

InterleavedGuard:

	SQUAREOPEN SQUARECLOSE GuardOp;

	SQUAREOPEN SQUARECLOSE guardOp=GuardOp;

AltConstruct:

	ALTKEYWORD LBRACKET AltGuardList RBRACKET;

	ALTKEYWORD LBRACKET agList=AltGuardList RBRACKET;

AltGuardList:

	{AltGuardList} (guardList+=GuardStatement | elseList+=ElseStatement SEMICOLON?)*;

ElseStatement:

	SQUAREOPEN ELSEKEYWORD SQUARECLOSE StatementBlock;

	SQUAREOPEN ELSEKEYWORD SQUARECLOSE block=StatementBlock;

GuardStatement:

	guard=AltGuardChar (step=AltstepInstance block=StatementBlock? | op=GuardOp block=StatementBlock);

	PORTREDIRECTSYMBOL RedirectWithValueAndParamSpec;

RedirectWithValueAndParamSpec:

	value=ValueSpec param=ParamSpec? sender=SenderSpec? | RedirectWithParamSpec;

	value=ValueSpec param=ParamSpec? sender=SenderSpec? | redirect=RedirectWithParamSpec;

ValueMatchSpec:

	VALUEKEYWORD InLineTemplate;

	VALUEKEYWORD template=InLineTemplate;

CatchStatement:

	PortOrAny DOT catch=PortCatchOp;

	{PortCatchOp} CATCHOPKEYWORD (LPAREN param=CatchOpParameter RPAREN)? from=FromClause? redirect=PortRedirect?;

CatchOpParameter:

	{CatchOpParameter} Signature COMMA template=InLineTemplate | {CatchOpParameter} TIMEOUTKEYWORD;

	signature=Signature COMMA template=InLineTemplate | {CatchOpParameter} TIMEOUTKEYWORD;

GetCallStatement:

	PortOrAny DOT call=PortGetCallOp;

	redirect=PortRedirectWithParam?;

PortRedirectWithParam:

	PORTREDIRECTSYMBOL RedirectWithParamSpec;

	PORTREDIRECTSYMBOL redirect=RedirectWithParamSpec;

RedirectWithParamSpec:

	ParamSpec sender=SenderSpec? | sender=SenderSpec;

	array=ArrayIdentifierRef DOT op=PortRaiseOp;

PortRaiseOp:

	RAISEKEYWORD LPAREN Signature COMMA InLineTemplate RPAREN to=ToClause?;

	RAISEKEYWORD LPAREN signature=[SignatureDef|IDENTIFIER] COMMA template=InLineTemplate RPAREN to=ToClause?;

ReplyStatement:

	array=ArrayIdentifierRef DOT op=PortReplyOp;

	variables+=SingleVarInstance (COMMA variables+=SingleVarInstance)*;

ReferencedType:

	SubTypeDefNamed | RecordDefNamed | SetDefNamed | PortDef | ComponentDef | UnionDefNamed | EnumDefNamed | RecordOfDefNamed | SetOfDefNamed;

	SubTypeDefNamed | RecordDefNamed | SetDefNamed | PortDef | ComponentDef | UnionDefNamed | EnumDefNamed |

	RecordOfDefNamed | SetOfDefNamed | SignatureDef;

TypeDef:

	TYPEDEFKEYWORD body=TypeDefBody;

	attribs=PortDefAttribs;

PortDefAttribs:

	MessageAttribs | ProcedureAttribs | MixedAttribs;

	message=MessageAttribs | procedure=ProcedureAttribs | mixed=MixedAttribs;

MixedAttribs:

	{MixedAttribs} MIXEDKEYWORD LBRACKET ((decl+=AddressDecl | list+=MixedList | def+=ConfigParamDef) SEMICOLON?)+

ProcOrTypeList:

	{ProcOrTypeList} ALLKEYWORD | type+=ProcOrType (COMMA type+=ProcOrType)*;

/// changed Signature -> Type

ProcOrType:

	{ProcOrType} Signature | Type;

	type=Type;

MessageAttribs:

	MESSAGEKEYWORD LBRACKET ((adresses+=AddressDecl | messages+=MessageList | configs+=ConfigParamDef) SEMICOLON?)+

DerivedDef:

	MODIFIESKEYWORD name=ExtendedIdentifier;

/// changed Signature -> Type

BaseTemplate:

	(type=Type | Signature) name=IDENTIFIER (LPAREN parList=TemplateOrValueFormalParList RPAREN)?;

	type=Type name=IDENTIFIER (LPAREN parList=TemplateOrValueFormalParList RPAREN)?;

TempVarList:

	var+=SingleTempVarInstance (COMMA var+=SingleTempVarInstance)*;

SingleTempVarInstance:

	name=IDENTIFIER array=ArrayDef? (ac=ASSIGNMENTCHAR template=TemplateBody)?;

/// changed Signature -> Type

InLineTemplate:

	((type=Type | Signature) COLON)? (derived=DerivedRefWithParList ASSIGNMENTCHAR)? template=TemplateBody;

	(type=Type COLON)? (derived=DerivedRefWithParList ASSIGNMENTCHAR)? template=TemplateBody;

DerivedRefWithParList:

	MODIFIESKEYWORD template=TemplateRefWithParList;

	ALLKEYWORD FROMKEYWORD body=TemplateBody;

Signature:

	ExtendedIdentifier;

	ref=[SignatureDef|IDENTIFIER];

TemplateInstanceAssignment:

	name=IDENTIFIER ASSIGNMENTCHAR template=InLineTemplate;

		if (module.defs.checkNameClashModuleDefinitionsList(sig, sig.name)) {

			error('Name clash with another variable definition in this scope!',

				TTCN3Package.eINSTANCE.signatureDef_Name);

				TTCN3Package.eINSTANCE.referencedType_Name);

			return;

		}

	}