CheckScopes_CycleDependency.cpp

#include "WfAnalyzer.h"

namespace

{

namespace

workflow

{

namespace

analyzer

{

using

namespace

collections

;

using

namespace

reflection

;

using

namespace

reflection

description

;

using

namespace

typeimpl

;

/*********************************************************************** CheckBaseClass ***********************************************************************/

class

CheckCycleDependencyDeclarationVisitor

public

empty_visitor

DeclarationVisitor

public

empty_visitor

VirtualCseDeclarationVisitor

{

public

WfLexicalScopeManager

manager

;

ITypeDescriptor

tdDescriptableObject

description

GetTypeDescriptor

DescriptableObject

>();

ITypeDescriptor

tdIDescriptable

description

GetTypeDescriptor

IDescriptable

>();

vint

step

;

Dictionary

ITypeDescriptor

WfDeclaration

depItems

;

Group

ITypeDescriptor

depGroup

;

CheckCycleDependencyDeclarationVisitor

(

WfLexicalScopeManager

_manager

) :manager(

_manager

) { }

void

Dispatch

(

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

);)

{

decl

(

this

); } }

void

Dispatch

(

WfVirtualCseDeclaration

node

)

override

{

node

((

WfVirtualCseDeclaration

IVisitor

this

); }

void

Visit

(

WfNamespaceDeclaration

node

)

override

{

FOREACH(Ptr<WfDeclaration>, decl, 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

decl

;

__foreach_iterator__

(

decl

);)

{

decl

(

this

); } }

void

Visit

(

WfStructDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

manager

declarationTypes

[

node

Obj

();

(

step

) {

depItems

Add

(

node

); }

else

(

step

) {

vint

count

GetPropertyCount

();

for

(

vint

;

count

;

++) {

auto

propType

GetProperty

(

)->

GetReturn

();

(

propType

GetDecorator

() ==

ITypeInfo

TypeDescriptor

) {

auto

propTd

propType

GetTypeDescriptor

();

depItems

Keys

().

Contains

(

propTd

))

continue

;

(

propTd

) {

List

ITypeDescriptor

tds

;

tds

Add

(

);

manager

errors

Add

(

WfErrors

StructRecursivelyIncludeItself

(

node

tds

)); }

else

(

propTd

GetTypeDescriptorFlags

() ==

TypeDescriptorFlags

Struct

) {

depGroup

Contains

(

propTd

)) {

depGroup

Add

(

propTd

); } } } } } }

void

Visit

(

WfClassDeclaration

node

)

override

{

auto

scope

manager

nodeScopes

[

node

];

auto

manager

declarationTypes

[

node

Obj

();

(

step

) {

depItems

Add

(

node

); }

else

(

step

) {

vint

count

GetBaseTypeDescriptorCount

();

for

(

vint

;

count

;

++) {

auto

baseTd

GetBaseTypeDescriptor

(

);

bool

isClass

baseTd

GetTypeDescriptorFlags

() ==

TypeDescriptorFlags

Class

;

bool

isInterface

baseTd

GetTypeDescriptorFlags

() ==

TypeDescriptorFlags

Interface

;

switch

(

node

kind

) {

case

WfClassKind

Class

: {

isClass

|| !

baseTd

IsAggregatable

()) {

dynamic_cast

WfClass

*>(

baseTd

) &&

baseTd

tdDescriptableObject

) {

manager

errors

Add

(

WfErrors

WrongBaseTypeOfClass

(

node

baseTd

)); } } }

break

;

case

WfClassKind

Interface

: {

isInterface

baseTd

tdIDescriptable

) {

manager

errors

Add

(

WfErrors

WrongBaseTypeOfInterface

(

node

baseTd

)); } }

break

; }

depItems

Keys

().

Contains

(

baseTd

))

continue

;

(

baseTd

) {

List

ITypeDescriptor

tds

;

tds

Add

(

);

(

isClass

) {

manager

errors

Add

(

WfErrors

ClassRecursiveInheritance

(

node

tds

)); }

else

(

isInterface

) {

manager

errors

Add

(

WfErrors

InterfaceRecursiveInheritance

(

node

tds

)); } }

else

(

baseTd

GetTypeDescriptorFlags

() ==

GetTypeDescriptorFlags

()) {

depGroup

Contains

(

baseTd

)) {

depGroup

Add

(

baseTd

); } } } }

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

);)

{

memberDecl

(

this

); } }

void

Execute

(

vint

_step

) {

step

_step

;

FOREACH(Ptr<WfModule>, module, manager->GetModules())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModule

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

manager

GetModules

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModule

module

;

__foreach_iterator__

(

module

);)

{

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

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfDeclaration

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

module

declarations

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfDeclaration

declaration

;

__foreach_iterator__

(

declaration

);)

{

declaration

(

this

); } } }

void

ExecuteCollectTypes

() {

Execute

(

); }

void

ExecuteCollectDependencies

() {

Execute

(

); } };

/*********************************************************************** CheckScopes_CycleDependency ***********************************************************************/

void

CheckScopes_DuplicatedBaseClass

(

WfLexicalScopeManager

manager

WfClassDeclaration

node

ITypeDescriptor

) {

List

ITypeDescriptor

baseTypes

;

SortedList

ITypeDescriptor

duplicatedTypes

;

baseTypes

Add

(

);

for

(

vint

;

baseTypes

Count

();

++) {

auto

currentTd

baseTypes

[

];

vint

count

currentTd

GetBaseTypeDescriptorCount

();

for

(

vint

;

count

;

++) {

auto

baseTd

currentTd

GetBaseTypeDescriptor

(

);

(

baseTd

GetTypeDescriptorFlags

() ==

TypeDescriptorFlags

Class

baseTd

description

GetTypeDescriptor

DescriptableObject

>()) {

(

baseTypes

Contains

(

baseTd

)) {

duplicatedTypes

Contains

(

baseTd

)) {

duplicatedTypes

Add

(

baseTd

);

manager

errors

Add

(

WfErrors

DuplicatedBaseClass

(

node

baseTd

)); } }

else

{

baseTypes

Add

(

baseTd

); } } } } }

bool

CheckScopes_CycleDependency

(

WfLexicalScopeManager

manager

) {

vint

errorCount

manager

errors

Count

();

CheckCycleDependencyDeclarationVisitor

visitor

(

manager

);

visitor

ExecuteCollectTypes

();

visitor

ExecuteCollectDependencies

(); {

PartialOrderingProcessor

pop

;

pop

InitWithGroup

(

visitor

depItems

Keys

(),

visitor

depGroup

);

pop

Sort

();

for

(

vint

;

pop

components

Count

();

++) {

auto

component

pop

components

[

];

(

component

nodeCount

) {

List

ITypeDescriptor

tds

;

CopyFrom

(

tds

From

(

component

firstNode

component

firstNode

component

nodeCount

) .

Select

([&](

vint

nodeIndex

) {

return

visitor

depItems

Keys

()

[

nodeIndex

]; }) );

switch

(

tds

[

]->

GetTypeDescriptorFlags

()) {

case

TypeDescriptorFlags

Struct

manager

errors

Add

(

WfErrors

StructRecursivelyIncludeItself

(

dynamic_cast

WfStructDeclaration

*>(

visitor

depItems

[

tds

[

]]),

tds

));

break

;

case

TypeDescriptorFlags

Class

manager

errors

Add

(

WfErrors

ClassRecursiveInheritance

(

dynamic_cast

WfClassDeclaration

*>(

visitor

depItems

[

tds

[

]]),

tds

));

break

;

case

TypeDescriptorFlags

Interface

manager

errors

Add

(

WfErrors

InterfaceRecursiveInheritance

(

dynamic_cast

WfClassDeclaration

*>(

visitor

depItems

[

tds

[

]]),

tds

));

break

;

default

:; } } } }

(

errorCount

manager

errors

Count

()) {

for

(

vint

;

visitor

depItems

Count

();

++) {

auto

key

visitor

depItems

Keys

()

[

];

auto

value

dynamic_cast

WfClassDeclaration

*>(

visitor

depItems

Values

()

[

]);

(

value

kind

WfClassKind

Class

) {

CheckScopes_DuplicatedBaseClass

(

manager

value

key

); } } }

return

errorCount

manager

errors

Count

(); } } } }