WfAnalyzer_ValidateSemantic

#include "WfAnalyzer.h"

namespace

{

namespace

workflow

{

namespace

analyzer

{

using

namespace

collections

;

using

namespace

reflection

;

using

namespace

reflection

description

;

using

namespace

typeimpl

;

/*********************************************************************** ValidateSemantic(ClassMember) ***********************************************************************/

class

ValidateSemanticClassMemberVisitor

public

Object

public

WfDeclaration

IVisitor

{

public

WfLexicalScopeManager

manager

;

Ptr

WfCustomType

;

Ptr

WfClassDeclaration

classDecl

;

ValidateSemanticClassMemberVisitor

(

Ptr

WfCustomType

_td

Ptr

WfClassDeclaration

_classDecl

WfLexicalScopeManager

_manager

) :td(

_td

) , classDecl(

_classDecl

) , manager(

_manager

) { }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{ }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfVariableDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfEventDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfPropertyDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

);

auto

scope

manager

nodeScopes

[

node

];

(

auto

typeInfo

CreateTypeInfoFromType

(

scope

Obj

(),

node

type

)) {

(

node

getter

value

L""

) {

auto

getter

GetMethodGroupByName

(

node

getter

value

false

)->

GetMethod

(

);

IsSameType

(

typeInfo

Obj

(),

getter

GetReturn

()) ||

getter

GetParameterCount

() !=

) {

manager

errors

Add

(

WfErrors

PropertyGetterTypeMismatched

(

node

classDecl

Obj

())); } }

(

node

setter

value

L""

) {

auto

setter

GetMethodGroupByName

(

node

setter

value

false

)->

GetMethod

(

);

(

setter

GetReturn

()->

GetTypeDescriptor

() !=

description

GetTypeDescriptor

void

>() ||

setter

GetParameterCount

() !=

|| !

IsSameType

(

typeInfo

Obj

(),

setter

GetParameter

(

)->

GetType

())) {

manager

errors

Add

(

WfErrors

PropertySetterTypeMismatched

(

node

classDecl

Obj

())); } } } }

static

void

SelectConstructor

(

WfLexicalScopeManager

manager

WfConstructorDeclaration

ctorDecl

parsing

ParsingTreeCustomBase

node

ITypeDescriptor

List

Ptr

WfExpression

>>&

arguments

) {

List

ResolveExpressionResult

functions

;

(

auto

ctors

GetConstructorGroup

()) {

vint

count

ctors

GetMethodCount

();

for

(

vint

;

count

;

++) {

auto

ctor

ctors

GetMethod

(

);

functions

Add

(

ResolveExpressionResult

Method

(

ctor

)); } }

vint

selectedFunctionIndex

= -

;

SelectFunction

(

manager

node

nullptr

functions

arguments

selectedFunctionIndex

);

(

selectedFunctionIndex

!= -

) {

auto

ctor

functions

[

selectedFunctionIndex

methodInfo

;

auto

call

dynamic_cast

WfBaseConstructorCall

*>(

node

);

manager

baseConstructorCallResolvings

Add

({

ctorDecl

}, {

call

ctor

}); } }

void

Visit

(

WfConstructorDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

);

auto

scope

manager

nodeScopes

[

node

Obj

();

auto

classScope

scope

parentScope

Obj

();

SortedList

ITypeDescriptor

baseTypes

initTypes

; {

auto

classScope

typeOfThisExpr

;

vint

count

GetBaseTypeDescriptorCount

();

for

(

vint

;

count

;

++) {

auto

baseTd

GetBaseTypeDescriptor

(

);

baseTypes

Contains

(

baseTd

)) {

baseTypes

Add

(

baseTd

); } } }

FOREACH(Ptr<WfBaseConstructorCall>, call, node->baseConstructorCalls)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfBaseConstructorCall

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

baseConstructorCalls

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfBaseConstructorCall

call

;

__foreach_iterator__

(

call

);)

{

(

auto

scopeName

GetScopeNameFromReferenceType

(

classScope

call

type

)) {

(

auto

scopeName

typeDescriptor

) {

(

initTypes

Contains

(

)) {

manager

errors

Add

(

WfErrors

DuplicatedBaseConstructorCall

(

call

Obj

(),

)); }

else

(

baseTypes

Contains

(

)) {

initTypes

Add

(

);

SelectConstructor

(

manager

node

call

Obj

(),

call

arguments

); }

else

{

manager

errors

Add

(

WfErrors

WrongBaseConstructorCall

(

call

Obj

(),

)); } } } } {

vint

index

= -

;

for

(

vint

;

initTypes

Count

();

++) {

while

(

baseTypes

[

index

] !=

initTypes

[

]) {

auto

baseTypes

[

index

];

List

Ptr

WfExpression

arguments

;

SelectConstructor

(

manager

node

arguments

); } }

while

(++

index

baseTypes

Count

()) {

auto

baseTypes

[

index

];

List

Ptr

WfExpression

arguments

;

SelectConstructor

(

manager

node

arguments

); } }

ValidateStatementSemantic

(

manager

node

statement

); }

void

Visit

(

WfDestructorDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

);

ValidateStatementSemantic

(

manager

node

statement

); }

void

Visit

(

WfClassDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfEnumDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfStructDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfVirtualCfeDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

void

Visit

(

WfVirtualCseDeclaration

node

)

override

{

ValidateDeclarationSemantic

(

manager

node

); }

static

void

Execute

(

Ptr

WfCustomType

Ptr

WfClassDeclaration

classDecl

Ptr

WfDeclaration

memberDecl

WfLexicalScopeManager

manager

) {

ValidateSemanticClassMemberVisitor

visitor

(

classDecl

manager

);

memberDecl

visitor

); } };

/*********************************************************************** ValidateSemantic(Declaration) ***********************************************************************/

class

ExpandVirtualDeclarationVisitor

public

Object

public

WfVirtualCseDeclaration

IVisitor

{

public

WfLexicalScopeManager

manager

;

ExpandVirtualDeclarationVisitor

(

WfLexicalScopeManager

_manager

) :manager(

_manager

) { }

void

Visit

(

WfStateMachineDeclaration

node

)

override

{

ExpandStateMachine

(

manager

node

); } };

class

ValidateSemanticDeclarationVisitor

public

Object

public

WfDeclaration

IVisitor

public

WfVirtualCseDeclaration

IVisitor

{

public

WfLexicalScopeManager

manager

;

ValidateSemanticDeclarationVisitor

(

WfLexicalScopeManager

_manager

) :manager(

_manager

) { }

void

Visit

(

List

Ptr

WfAttribute

>>&

attributes

) {

FOREACH(Ptr<WfAttribute>, attribute, attributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

attributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfAttribute

attribute

;

__foreach_iterator__

(

attribute

);)

{

auto

key

Pair

WString

attribute

category

value

attribute

name

value

);

vint

index

manager

attributes

Keys

().

IndexOf

(

key

);

(

index

== -

) {

manager

errors

Add

(

WfErrors

AttributeNotExists

(

attribute

Obj

())); }

else

{

auto

expectedType

manager

attributes

Values

()

[

index

];

(

attribute

value

) {

ValidateConstantExpression

(

manager

attribute

value

expectedType

); }

else

(

expectedType

GetTypeDescriptor

() !=

description

GetTypeDescriptor

void

>()) {

manager

errors

Add

(

WfErrors

AttributeMissValue

(

attribute

Obj

())); } } } }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{

FOREACH(Ptr<WfDeclaration>, declaration, node->declarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

declaration

;

__foreach_iterator__

(

declaration

);)

{

ValidateDeclarationSemantic

(

manager

declaration

); } }

void

Visit

(

WfFunctionDeclaration

node

)

override

{

(

node

statement

) {

ValidateStatementSemantic

(

manager

node

statement

); }

FOREACH(Ptr<WfFunctionArgument>, argument, node->arguments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfFunctionArgument

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

arguments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfFunctionArgument

argument

;

__foreach_iterator__

(

argument

);)

{

Visit

(

argument

attributes

); } }

void

Visit

(

WfVariableDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

symbol

scope

symbols

[

node

name

value

]

[

];

symbol

typeInfo

GetExpressionType

(

manager

node

expression

symbol

typeInfo

);

(

symbol

typeInfo

&& !

symbol

type

) {

symbol

type

GetTypeFromTypeInfo

(

symbol

typeInfo

Obj

()); } }

void

Visit

(

WfEventDeclaration

node

)

override

{ }

void

Visit

(

WfPropertyDeclaration

node

)

override

{ }

void

Visit

(

WfConstructorDeclaration

node

)

override

{ }

void

Visit

(

WfDestructorDeclaration

node

)

override

{ }

void

Visit

(

WfClassDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

manager

declarationTypes

[

node

Cast

WfCustomType

>();

(

node

kind

WfClassKind

Interface

) {

FOREACH(Ptr<WfType>, baseType, node->baseTypes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfType

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

baseTypes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfType

baseType

;

__foreach_iterator__

(

baseType

);)

{

auto

scopeName

GetScopeNameFromReferenceType

(

scope

parentScope

Obj

(),

baseType

);

auto

baseTd

scopeName

typeDescriptor

;

auto

ctor

FindInterfaceConstructor

(

baseTd

);

(

ctor

nullptr

) {

manager

errors

Add

(

WfErrors

WrongInterfaceBaseType

(

node

baseTd

)); } } }

(

auto

From

(

node

declarations

) .FindType<

WfStateMachineDeclaration

>() .First(

nullptr

) ) {

auto

smtd

description

GetTypeDescriptor

StateMachine

>();

vint

count

GetBaseTypeDescriptorCount

();

auto

smbc

Range

vint

count

) .

Select

([=](

vint

index

) {

return

GetBaseTypeDescriptor

(

index

); }) .

Where

([=](

ITypeDescriptor

) {

return

smtd

; }) .

First

(

nullptr

);

smbc

) {

manager

errors

Add

(

WfErrors

StateMachineClassNotInheritFromStateMachine

(

node

)); } }

FOREACH(Ptr<WfDeclaration>, memberDecl, node->declarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

memberDecl

;

__foreach_iterator__

(

memberDecl

);)

{

ValidateClassMemberSemantic

(

manager

node

memberDecl

); } }

void

Visit

(

WfEnumDeclaration

node

)

override

{

FOREACH(Ptr<WfEnumItem>, item, node->items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfEnumItem

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfEnumItem

item

;

__foreach_iterator__

(

item

);)

{

Visit

(

item

attributes

); } }

void

Visit

(

WfStructDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

manager

declarationTypes

[

node

Cast

WfStruct

>();

FOREACH(Ptr<WfStructMember>, member, node->members)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfStructMember

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

members

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfStructMember

member

;

__foreach_iterator__

(

member

);)

{

auto

memberTd

GetPropertyByName

(

member

name

value

false

)->

GetReturn

()->

GetTypeDescriptor

();

((

memberTd

GetTypeDescriptorFlags

()

TypeDescriptorFlags

ReferenceType

) !=

TypeDescriptorFlags

Undefined

) {

manager

errors

Add

(

WfErrors

StructContainsNonValueType

(

member

Obj

(),

node

)); } }

FOREACH(Ptr<WfStructMember>, member, node->members)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfStructMember

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

members

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfStructMember

member

;

__foreach_iterator__

(

member

);)

{

Visit

(

member

attributes

); } }

void

Visit

(

WfVirtualCfeDeclaration

node

)

override

{

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

ValidateDeclarationSemantic

(

manager

decl

); } }

void

Visit

(

WfVirtualCseDeclaration

node

)

override

{

bool

expanded

node

expandedDeclarations

Count

() >

;

vint

errorCount

manager

errors

Count

();

node

((

WfVirtualCseDeclaration

IVisitor

this

);

expanded

manager

errors

Count

() ==

errorCount

) {

ExpandVirtualDeclarationVisitor

visitor

(

manager

);

node

visitor

);

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

SetCodeRange

(

decl

node

codeRange

); }

auto

parentScope

manager

nodeScopes

[

node

];

(

parentScope

ownerNode

node

) {

parentScope

; }

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

ContextFreeDeclarationDesugar

(

manager

decl

); }

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

BuildScopeForDeclaration

(

manager

parentScope

decl

manager

declaractionScopeSources

[

node

]); }

manager

checkedScopes_DuplicatedSymbol

Remove

(

parentScope

Obj

());

manager

checkedScopes_SymbolType

Remove

(

parentScope

Obj

());

CheckScopes_DuplicatedSymbol

(

manager

) || !

CheckScopes_SymbolType

(

manager

)) {

return

; } }

FOREACH(Ptr<WfDeclaration>, decl, node->expandedDeclarations)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

expandedDeclarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

decl

;

__foreach_iterator__

(

decl

);)

{

ValidateDeclarationSemantic

(

manager

decl

); } }

void

Visit

(

WfStateMachineDeclaration

node

)

override

{

bool

foundDefaultState

false

;

FOREACH(Ptr<WfStateDeclaration>, state, node->states)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfStateDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

states

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfStateDeclaration

state

;

__foreach_iterator__

(

state

);)

{

(

state

name

value

L""

) {

foundDefaultState

true

; }

ValidateStatementSemantic

(

manager

state

statement

); }

foundDefaultState

) {

manager

errors

Add

(

WfErrors

MissingDefaultState

(

node

)); } }

static

void

Execute

(

Ptr

WfDeclaration

declaration

WfLexicalScopeManager

manager

) {

ValidateSemanticDeclarationVisitor

visitor

(

manager

);

declaration

visitor

);

visitor

Visit

(

declaration

attributes

); } };

/*********************************************************************** ValidateSemantic ***********************************************************************/

void

ValidateClassMemberSemantic

(

WfLexicalScopeManager

manager

Ptr

typeimpl

WfCustomType

Ptr

WfClassDeclaration

classDecl

Ptr

WfDeclaration

memberDecl

) {

return

ValidateSemanticClassMemberVisitor

Execute

(

classDecl

memberDecl

manager

); }

void

ValidateDeclarationSemantic

(

WfLexicalScopeManager

manager

Ptr

WfDeclaration

declaration

) {

return

ValidateSemanticDeclarationVisitor

Execute

(

declaration

manager

); } } } }