WfAnalyzer.cpp

#include "WfAnalyzer.h"

namespace

{

namespace

workflow

{

namespace

analyzer

{

using

namespace

collections

;

using

namespace

reflection

description

;

/*********************************************************************** WfLexicalSymbol ***********************************************************************/

WfLexicalSymbol

(

WfLexicalScope

_ownerScope

) :ownerScope(

_ownerScope

) { }

WfLexicalSymbol

() { }

WString

WfLexicalSymbol

GetFriendlyName

() {

return

ownerScope

GetFriendlyName

() +

L"::"

name

; }

/*********************************************************************** WfLexicalScope ***********************************************************************/

WfLexicalScope

(

WfLexicalScopeManager

_ownerManager

) :ownerManager(

_ownerManager

) { }

WfLexicalScope

(

Ptr

WfLexicalScope

_parentScope

) :ownerManager(

) , parentScope(

_parentScope

) { }

WfLexicalScope

() { }

WfLexicalScopeManager

WfLexicalScope

FindManager

() {

WfLexicalScope

scope

this

;

while

(

scope

) {

(

scope

ownerManager

) {

return

scope

ownerManager

; }

scope

parentScope

Obj

(); }

return

; }

Ptr

WfModule

WfLexicalScope

FindModule

() {

WfLexicalScope

scope

this

;

while

(

scope

) {

(

auto

module

scope

ownerNode

Cast

WfModule

>()) {

return

module

; }

scope

parentScope

Obj

(); }

return

; }

WfLexicalScope

FindFunctionScope

() {

auto

scope

this

;

while

(

scope

) {

(

scope

functionConfig

) {

return

scope

; }

scope

parentScope

Obj

(); }

return

nullptr

; }

WString

WfLexicalScope

GetFriendlyName

() {

(

auto

module

ownerNode

Cast

WfModule

>()) {

return

L"<"

module

name

value

L">"

; }

else

(

auto

decl

ownerNode

Cast

WfDeclaration

>()) {

auto

name

decl

name

value

;

(

name

L""

) {

name

L"<anonymous>"

; }

return

parentScope

GetFriendlyName

() +

L"::"

name

; }

else

parentScope

) {

return

L""

; }

else

{

return

parentScope

GetFriendlyName

() +

L"::<>"

; } }

Ptr

WfClassMember

WfLexicalScope

GetOwnerClassMember

() {

(

auto

decl

ownerNode

Cast

WfDeclaration

>()) {

return

decl

classMember

; }

return

nullptr

; }

/*********************************************************************** WfLexicalScopeName ***********************************************************************/

WfLexicalScopeName

(

bool

_imported

) :imported(

_imported

) { }

WfLexicalScopeName

() { }

Ptr

WfLexicalScopeName

AccessChild

(

const

WString

name

bool

imported

) {

vint

index

children

Keys

().

IndexOf

(

name

);

(

index

== -

) {

Ptr

WfLexicalScopeName

newName

new

WfLexicalScopeName

(

imported

);

newName

name

;

newName

parent

this

;

children

Add

(

name

newName

);

return

newName

; }

else

{

return

children

Values

()

[

index

]; } }

void

WfLexicalScopeName

RemoveNonTypeDescriptorNames

(

WfLexicalScopeManager

manager

) {

FOREACH(Ptr<WfLexicalScopeName>, name, children.Values())

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalScopeName

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

children

Values

());

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalScopeName

name

;

__foreach_iterator__

(

name

);)

{

name

RemoveNonTypeDescriptorNames

(

manager

); }

for

(

vint

children

Count

() -

;

--) {

auto

subScopeName

children

Values

()

[

];

subScopeName

imported

) {

children

Remove

(

children

Keys

()

[

]);

(

subScopeName

typeDescriptor

) {

manager

typeNames

Remove

(

subScopeName

typeDescriptor

); } } }

declarations

Clear

(); }

WString

WfLexicalScopeName

GetFriendlyName

() {

(

parent

) {

WString

parentName

parent

GetFriendlyName

();

(

parentName

L""

) {

return

name

; }

else

{

return

parentName

L"::"

name

; } }

else

{

return

L""

; } }

/*********************************************************************** ResolveExpressionResult ***********************************************************************/

WString

ResolveExpressionResult

GetFriendlyName

(

bool

upperCase

)

const

{

WString

typeName

result

;

(

type

) {

typeName

= +

L" of type \""

type

GetTypeFriendlyName

() +

L"\""

; }

(

scopeName

) {

result

scopeName

GetFriendlyName

(); }

else

(

symbol

) {

result

symbol

GetFriendlyName

() +

typeName

; }

else

(

propertyInfo

) {

result

L"property \""

propertyInfo

GetName

() +

L"\" in \""

propertyInfo

GetOwnerTypeDescriptor

()->

GetTypeName

() +

L"\""

typeName

; }

else

(

methodInfo

) {

(

methodInfo

GetName

()

L""

) {

result

L"constructor in \""

methodInfo

GetOwnerTypeDescriptor

()->

GetTypeName

() +

L"\""

typeName

; }

else

{

result

L"method \""

methodInfo

GetName

() +

L"\" in \""

methodInfo

GetOwnerTypeDescriptor

()->

GetTypeName

() +

L"\""

typeName

; } }

else

(

eventInfo

) {

result

L"event \""

eventInfo

GetName

() +

L"\" in \""

eventInfo

GetOwnerTypeDescriptor

()->

GetTypeName

() +

L"\""

; }

else

(

type

) {

result

L"expression"

typeName

; }

else

{

result

L"<unknown>"

; }

(

result

Length

() >

upperCase

) {

result = INVLOC.ToUpper(result.Left(1)) + result.Right(result.Length() - 1);

result

Locale

Invariant

().

ToUpper

(

result

Left

(

)) +

result

Right

(

result

Length

() -

);

}

return

result

; }

ResolveExpressionResult

ScopeName

(

Ptr

WfLexicalScopeName

_scopeName

) {

ResolveExpressionResult

result

;

result

scopeName

_scopeName

;

return

result

; }

ResolveExpressionResult

ReadonlySymbol

(

Ptr

WfLexicalSymbol

_symbol

) {

ResolveExpressionResult

result

;

result

symbol

_symbol

;

result

type

_symbol

typeInfo

;

return

result

; }

ResolveExpressionResult

Symbol

(

Ptr

WfLexicalSymbol

_symbol

) {

ResolveExpressionResult

result

;

result

symbol

_symbol

;

result

type

_symbol

typeInfo

;

(

_symbol

creatorNode

Cast

WfVariableDeclaration

>()) {

result

writableType

_symbol

typeInfo

; }

return

result

; }

ResolveExpressionResult

ReadonlyType

(

Ptr

reflection

description

ITypeInfo

_type

) {

ResolveExpressionResult

result

;

result

type

_type

;

return

result

; }

ResolveExpressionResult

WritableType

(

Ptr

reflection

description

ITypeInfo

_type

) {

ResolveExpressionResult

result

;

result

type

_type

;

result

writableType

_type

;

return

result

; }

ResolveExpressionResult

Property

(

reflection

description

IPropertyInfo

_propertyInfo

) {

Ptr

ITypeInfo

getterType

CopyTypeInfo

(

_propertyInfo

GetReturn

());

Ptr

ITypeInfo

setterType

;

(

getterType

) {

(

IMethodInfo

setter

_propertyInfo

GetSetter

()) {

setterType

getterType

;

(

setter

GetParameterCount

() ==

&& !

IsSameType

(

getterType

Obj

(),

setter

GetParameter

(

)->

GetType

())) {

setterType

CopyTypeInfo

(

setter

GetParameter

(

)->

GetType

()); } }

else

(

_propertyInfo

IsWritable

()) {

auto

_propertyInfo

GetOwnerTypeDescriptor

();

((

GetTypeDescriptorFlags

()

TypeDescriptorFlags

ReferenceType

) !=

TypeDescriptorFlags

Undefined

) {

setterType

CopyTypeInfo

(

_propertyInfo

GetReturn

()); } } }

ResolveExpressionResult

result

;

result

propertyInfo

_propertyInfo

;

result

type

getterType

;

result

writableType

setterType

;

return

result

; }

ResolveExpressionResult

Method

(

reflection

description

IMethodInfo

_methodInfo

) {

ResolveExpressionResult

result

;

result

methodInfo

_methodInfo

;

result

type

CreateTypeInfoFromMethodInfo

(

_methodInfo

);

return

result

; }

ResolveExpressionResult

Constructor

(

reflection

description

IMethodInfo

_constructorInfo

) {

ResolveExpressionResult

result

;

result

constructorInfo

_constructorInfo

;

result

type

CopyTypeInfo

(

_constructorInfo

GetReturn

());

return

result

; }

ResolveExpressionResult

Event

(

reflection

description

IEventInfo

_eventInfo

) {

ResolveExpressionResult

result

;

result

eventInfo

_eventInfo

;

return

result

; }

bool

IsSameTypeOrNull

(

ITypeInfo

fromType

ITypeInfo

toType

) {

(

fromType

toType

)

return

true

;

((

fromType

nullptr

) ^ (

toType

nullptr

))

return

false

;

return

IsSameType

(

fromType

toType

); }

bool

ResolveExpressionResult

operator

(

const

ResolveExpressionResult

result

)

const

{

(

scopeName

result

scopeName

)

return

false

;

(

symbol

result

symbol

)

return

false

;

(

propertyInfo

result

propertyInfo

)

return

false

;

(

methodInfo

result

methodInfo

)

return

false

;

(

constructorInfo

result

constructorInfo

)

return

false

;

(

eventInfo

result

eventInfo

)

return

false

;

IsSameTypeOrNull

(

type

Obj

(),

result

type

Obj

()))

return

false

;

IsSameTypeOrNull

(

writableType

Obj

(),

result

writableType

Obj

()))

return

false

;

IsSameTypeOrNull

(

expectedType

Obj

(),

result

expectedType

Obj

()))

return

false

;

return

true

; }

bool

ResolveExpressionResult

operator

(

const

ResolveExpressionResult

result

)

const

{

return

!(*

this

result

); }

/*********************************************************************** WfLexicalScopeManager ***********************************************************************/

WfLexicalScopeManager

(

Ptr

parsing

tabling

ParsingTable

_parsingTable

) :parsingTable(

_parsingTable

) {

attributes

Add

({

L"cpp"

L"File"

TypeInfoRetriver

WString

>::

CreateTypeInfo

());

attributes

Add

({

L"cpp"

L"UserImpl"

TypeInfoRetriver

void

>::

CreateTypeInfo

());

attributes

Add

({

L"cpp"

L"Private"

TypeInfoRetriver

void

>::

CreateTypeInfo

());

attributes

Add

({

L"cpp"

L"Protected"

TypeInfoRetriver

void

>::

CreateTypeInfo

());

attributes

Add

({

L"cpp"

L"Friend"

TypeInfoRetriver

ITypeDescriptor

*>::

CreateTypeInfo

()); }

WfLexicalScopeManager

() { }

vint

WfLexicalScopeManager

AddModule

(

const

WString

moduleCode

) {

(

auto

module

WfParseModule

(

moduleCode

parsingTable

errors

usedCodeIndex

)) {

modules

Add

(

module

);

moduleCodes

Add

(

moduleCode

); }

return

usedCodeIndex

++; }

vint

WfLexicalScopeManager

AddModule

(

Ptr

WfModule

module

) {

module

codeRange

codeIndex

usedCodeIndex

;

modules

Add

(

module

);

moduleCodes

Add

(

L""

);

return

usedCodeIndex

++; }

WfLexicalScopeManager

ModuleList

WfLexicalScopeManager

GetModules

() {

return

modules

; }

WfLexicalScopeManager

ModuleCodeList

WfLexicalScopeManager

GetModuleCodes

() {

return

moduleCodes

; }

void

WfLexicalScopeManager

Clear

(

bool

keepTypeDescriptorNames

bool

deleteModules

) {

(

globalName

) {

(

keepTypeDescriptorNames

) {

globalName

RemoveNonTypeDescriptorNames

(

this

); }

else

{

globalName

;

typeNames

Clear

(); } }

(

deleteModules

) {

modules

Clear

();

moduleCodes

Clear

();

usedCodeIndex

; }

usedTempVars

;

errors

Clear

();

namespaceNames

Clear

();

nodeScopes

Clear

();

checkedScopes_DuplicatedSymbol

Clear

();

checkedScopes_SymbolType

Clear

();

expressionResolvings

Clear

();

coNewCoroutineResolvings

Clear

();

coOperatorResolvings

Clear

();

coProviderResolvings

Clear

();

coCastResultResolvings

Clear

();

baseConstructorCallResolvings

Clear

();

lambdaCaptures

Clear

();

interfaceMethodImpls

Clear

();

declaractionScopeSources

Clear

();

declarationTypes

Clear

();

declarationMemberInfos

Clear

();

stateInputMethods

Clear

();

stateInputArguments

Clear

();

stateDeclArguments

Clear

();

stateMachineInfos

Clear

(); }

#define EXECUTE_CALLBACK(EXPR) if (callback) callback->EXPR

void

WfLexicalScopeManager

Rebuild

(

bool

keepTypeDescriptorNames

IWfCompilerCallback

callback

) {

EXECUTE_CALLBACK(OnLoadEnvironment());

(

callback

)

callback

OnLoadEnvironment

();

Clear

(

keepTypeDescriptorNames

false

);

globalName

) {

globalName

new

WfLexicalScopeName

(

true

);

BuildGlobalNameFromTypeDescriptors

(

this

); }

EXECUTE_CALLBACK(OnInitialize(this));

(

callback

)

callback

OnInitialize

(

this

);

vint

errorCount

errors

Count

();

#define EXIT_IF_ERRORS_EXIST\

do\

if (errors.Count() != errorCount) return;\

}while (0)

EXIT_IF_ERRORS_EXIST;

{

(

errors

Count

() !=

errorCount

)

return

; }

while

(

);

FOREACH(Ptr<WfModule>, module, modules)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModule

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

modules

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModule

module

;

__foreach_iterator__

(

module

);)

{

ContextFreeModuleDesugar

(

this

module

);

ValidateModuleStructure

(

this

module

); }

EXIT_IF_ERRORS_EXIST;

{

(

errors

Count

() !=

errorCount

)

return

; }

while

(

);

BuildGlobalNameFromModules

(

this

);

FOREACH(Ptr<WfModule>, module, modules)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModule

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

modules

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModule

module

;

__foreach_iterator__

(

module

);)

{

BuildScopeForModule

(

this

module

); }

ValidateScopeName

(

this

globalName

);

CheckScopes_DuplicatedSymbol

(

this

);

EXIT_IF_ERRORS_EXIST;

{

(

errors

Count

() !=

errorCount

)

return

; }

while

(

);

FOREACH(Ptr<WfModule>, module, modules)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModule

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

modules

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModule

module

;

__foreach_iterator__

(

module

);)

{

CompleteScopeForModule

(

this

module

); }

CheckScopes_SymbolType

(

this

);

CheckScopes_CycleDependency

(

this

);

EXIT_IF_ERRORS_EXIST;

{

(

errors

Count

() !=

errorCount

)

return

; }

while

(

);

FOREACH(Ptr<WfModule>, module, modules)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModule

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

modules

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModule

module

;

__foreach_iterator__

(

module

);)

{

EXECUTE_CALLBACK(OnValidateModule(module));

(

callback

)

callback

OnValidateModule

(

module

);

ValidateModuleSemantic

(

this

module

); }

#undef EXIT_IF_ERRORS_EXIST

}

#undef EXECUTE_CALLBACK

bool

WfLexicalScopeManager

ResolveMember

(

ITypeDescriptor

typeDescriptor

const

WString

name

bool

preferStatic

collections

SortedList

ITypeDescriptor

*>&

searchedTypes

collections

List

ResolveExpressionResult

results

) {

(

searchedTypes

Contains

(

typeDescriptor

)) {

return

true

; }

searchedTypes

Add

(

typeDescriptor

);

bool

found

false

;

bool

foundStaticMember

false

;

((

typeDescriptor

GetTypeDescriptorFlags

()

TypeDescriptorFlags

EnumType

) !=

TypeDescriptorFlags

Undefined

) {

(

preferStatic

) {

auto

enumType

typeDescriptor

GetEnumType

();

vint

index

enumType

IndexOfItem

(

name

);

(

index

!= -

) {

results

Add

(

ResolveExpressionResult

ReadonlyType

(

MakePtr

TypeDescriptorTypeInfo

typeDescriptor

TypeInfoHint

Normal

)));

return

true

; } }

return

false

; } {

auto

scopeName

typeNames

[

typeDescriptor

];

vint

index

scopeName

children

Keys

().

IndexOf

(

name

);

(

index

!= -

) {

auto

subScopeName

scopeName

children

Values

()

[

index

];

found

true

;

foundStaticMember

true

;

results

Add

(

ResolveExpressionResult

ScopeName

(

subScopeName

)); } }

(

auto

group

typeDescriptor

GetMethodGroupByName

(

name

false

)) {

for

(

vint

;

group

GetMethodCount

();

++) {

auto

info

group

GetMethod

(

);

(

info

IsStatic

()) {

found

true

;

foundStaticMember

true

;

results

Add

(

ResolveExpressionResult

Method

(

info

)); } } }

(

foundStaticMember

preferStatic

) {

return

true

; }

(

auto

group

typeDescriptor

GetMethodGroupByName

(

name

false

)) {

for

(

vint

;

group

GetMethodCount

();

++) {

auto

info

group

GetMethod

(

);

info

IsStatic

()) {

found

true

;

results

Add

(

ResolveExpressionResult

Method

(

info

)); } } }

(

auto

info

typeDescriptor

GetPropertyByName

(

name

false

)) {

found

true

;

results

Add

(

ResolveExpressionResult

Property

(

info

)); }

(

auto

info

typeDescriptor

GetEventByName

(

name

false

)) {

found

true

;

results

Add

(

ResolveExpressionResult

Event

(

info

)); }

found

) {

vint

count

typeDescriptor

GetBaseTypeDescriptorCount

();

for

(

vint

;

count

;

++) {

(

ResolveMember

(

typeDescriptor

GetBaseTypeDescriptor

(

name

preferStatic

searchedTypes

results

)) {

found

true

; } } }

return

found

; }

class

UsingPathToNameVisitor

public

Object

public

WfModuleUsingFragment

IVisitor

{

public

WString

name

;

WString

result

;

UsingPathToNameVisitor

(

const

WString

_name

) :name(

_name

) { }

void

Visit

(

WfModuleUsingNameFragment

node

) {

result

node

name

value

; }

void

Visit

(

WfModuleUsingWildCardFragment

node

) {

result

name

; }

static

WString

Execute

(

Ptr

WfModuleUsingFragment

fragment

const

WString

name

) {

UsingPathToNameVisitor

visitor

(

name

);

fragment

visitor

);

return

visitor

result

; } };

bool

WfLexicalScopeManager

ResolveName

(

WfLexicalScope

scope

const

WString

name

collections

List

ResolveExpressionResult

results

) {

vint

oldResultCount

results

Count

();

bool

visibleToNonStatic

false

;

WfLexicalScope

firstConfigScope

nullptr

;

while

(

scope

) {

(

scope

ownerNode

Cast

WfModule

>() ||

scope

ownerNode

Cast

WfNamespaceDeclaration

>()) {

break

; }

(

scope

functionConfig

) {

visibleToNonStatic

scope

functionConfig

thisAccessable

scope

functionConfig

parentThisAccessable

;

firstConfigScope

) {

firstConfigScope

scope

; } }

vint

index

scope

symbols

Keys

().

IndexOf

(

name

);

(

index

!= -

) {

(

scope

typeOfThisExpr

) {

(

scope

ownerNode

Cast

WfNewInterfaceExpression

>()) {

FOREACH(Ptr<WfLexicalSymbol>, symbol, scope->symbols.GetByIndex(index))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

scope

symbols

GetByIndex

(

index

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

symbol

;

__foreach_iterator__

(

symbol

);)

{

(

symbol

creatorNode

Cast

WfVariableDeclaration

>()) {

auto

result

ResolveExpressionResult

Symbol

(

symbol

);

results

Contains

(

result

)) {

results

Add

(

result

); } }

else

(

symbol

creatorNode

Cast

WfDeclaration

>()

classMember

kind

WfClassMemberKind

Normal

) {

(

firstConfigScope

parentScope

scope

) {

auto

result

ResolveExpressionResult

Symbol

(

symbol

);

results

Contains

(

result

)) {

results

Add

(

result

); } } } } } }

else

{

FOREACH(Ptr<WfLexicalSymbol>, symbol, scope->symbols.GetByIndex(index))

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfLexicalSymbol

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

scope

symbols

GetByIndex

(

index

));

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfLexicalSymbol

symbol

;

__foreach_iterator__

(

symbol

);)

{

auto

result

ResolveExpressionResult

Symbol

(

symbol

);

results

Contains

(

result

)) {

results

Add

(

result

); } } } }

(

scope

typeOfThisExpr

) {

SortedList

ITypeDescriptor

searchedTypes

;

ResolveMember

(

scope

typeOfThisExpr

name

, !

visibleToNonStatic

searchedTypes

results

); }

scope

parentScope

Obj

(); }

while

(

scope

) {

(

auto

nsDecl

scope

ownerNode

Cast

WfNamespaceDeclaration

>()) {

auto

scopeName

namespaceNames

[

nsDecl

Obj

()];

vint

index

scopeName

children

Keys

().

IndexOf

(

name

);

(

index

!= -

) {

auto

subScopeName

scopeName

children

Values

()

[

index

];

auto

result

ResolveExpressionResult

ScopeName

(

subScopeName

);

results

Contains

(

result

)) {

results

Add

(

result

); } }

scope

parentScope

Obj

(); }

else

{

break

; } }

vint

index

globalName

children

Keys

().

IndexOf

(

name

);

(

index

!= -

) {

auto

subScopeName

globalName

children

Values

()

[

index

];

auto

result

ResolveExpressionResult

ScopeName

(

subScopeName

);

results

Contains

(

result

)) {

results

Add

(

result

); } }

(

auto

module

scope

ownerNode

Cast

WfModule

>()) {

FOREACH(Ptr<WfModuleUsingPath>, path, module->paths)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModuleUsingPath

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

module

paths

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModuleUsingPath

path

;

__foreach_iterator__

(

path

);)

{

auto

scopeName

globalName

;

FOREACH(Ptr<WfModuleUsingItem>, item, path->items)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModuleUsingItem

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

path

items

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModuleUsingItem

item

;

__foreach_iterator__

(

item

);)

{

WString

fragmentName

;

FOREACH(Ptr<WfModuleUsingFragment>, fragment, item->fragments)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

WfModuleUsingFragment

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

item

fragments

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

WfModuleUsingFragment

fragment

;

__foreach_iterator__

(

fragment

);)

{

fragmentName

UsingPathToNameVisitor

Execute

(

fragment

name

); }

vint

index

scopeName

children

Keys

().

IndexOf

(

fragmentName

);

(

index

== -

)

goto

USING_PATH_MATCHING_FAILED;

scopeName

children

Values

()

[

index

]; } {

auto

result

ResolveExpressionResult

ScopeName

(

scopeName

);

results

Contains

(

result

)) {

results

Add

(

result

); } } USING_PATH_MATCHING_FAILED:; } }

return

results

Count

() >

oldResultCount

; }

Ptr

WfLexicalSymbol

WfLexicalScopeManager

GetDeclarationSymbol

(

WfLexicalScope

scope

WfDeclaration

node

) {

auto

symbol

From

(

scope

parentScope

symbols

[

node

name

value

]) .

Where

([=](

Ptr

WfLexicalSymbol

symbol

) {

return

symbol

creatorNode

node

; }) .

First

();

return

symbol

; }

void

WfLexicalScopeManager

CreateLambdaCapture

(

parsing

ParsingTreeCustomBase

node

Ptr

WfLexicalCapture

capture

) {

capture

) {

capture

MakePtr

WfLexicalCapture

>(); }

lambdaCaptures

Add

(

node

capture

); } } } }