def dependencies_from_envcalls(self, node):
depsList = []
if 'qx.core.Environment' not in ClassesAll:
self.context['console'].warn(
"No qx.core.Environment available to extract feature keys from"
)
return depsList
qcEnvClass = ClassesAll['qx.core.Environment']
for env_operand in variantoptimizer.findVariantNodes(node):
call_node = env_operand.parent.parent
env_key = call_node.getChild("arguments").children[0].get(
"value", "")
className, classAttribute = qcEnvClass.classNameFromEnvKey(env_key)
if className and className in ClassesAll:
#print className
depsItem = DependencyItem(className, classAttribute, self.id,
env_operand.get('line', -1))
depsItem.isCall = True # treat as if actual call, to collect recursive deps
depsItem.node = call_node
# .inLoadContext
qx_idnode = treeutil.findFirstChainChild(
env_operand) # 'qx' node of 'qx.core.Environment....'
scope = qx_idnode.scope
depsItem.isLoadDep = scope.is_load_time
if depsItem.isLoadDep:
depsItem.needsRecursion = True
depsList.append(depsItem)
return depsList
def _analyzeClassDepsNode_1(self, node, depsList, inLoadContext, inDefer=False):
if node.type in ("file", "function", "catch"):
top_scope = node.scope
else:
top_scope = scopes.find_enclosing(node) # get enclosing scope of node
# import pydb; pydb.debugger()
for scope in top_scope.scope_iterator(): # walk through this and all nested scopes
for global_name, scopeVar in scope.globals().items(): # get the global symbols { sym_name: ScopeVar }
for node in scopeVar.uses: # create a depsItem for all its uses
depsItem = self.qualify_deps_item(node, scope.is_load_time, scope.is_defer)
depsList.append(depsItem) # and qualify them
# Augment with feature dependencies introduces with qx.core.Environment.get("...") calls
for envCall in variantoptimizer.findVariantNodes(node):
className, classAttribute = self.getClassNameFromEnvKey(
envCall.getChild("arguments").children[0].get("value", "")
)
if className:
depsItem = DependencyItem(className, classAttribute, self.id, envCall.get("line", -1))
depsItem.isCall = True # treat as if actual call, to collect recursive deps
# .inLoadContext
# get 'qx' node of 'qx.core.Environment....'
call_operand = envCall.getChild("operand").children[0]
qx_idnode = treeutil.findFirstChainChild(call_operand)
scope = qx_idnode.scope
inLoadContext = scope.is_load_time # get its scope's .is_load_time
depsItem.isLoadDep = inLoadContext
if inLoadContext:
depsItem.needsRecursion = True
depsList.append(depsItem)
return
def _isScopedVar(self, idStr, node, fileId):
res = False
head_node = treeutil.findFirstChainChild(node)
assert head_node and hasattr(head_node, 'scope')
var_name = head_node.get('value')
var_scope = head_node.scope.lookup_decl(var_name)
res = bool(var_scope)
return res
def _isScopedVar(self, idStr, node, fileId):
res = False
head_node = treeutil.findFirstChainChild(node)
assert head_node and hasattr(head_node, 'scope')
var_name = head_node.get('value')
var_scope = head_node.scope.lookup_decl(var_name)
res = bool(var_scope)
return res
def _analyzeClassDepsNode_2(self,
node,
depsList,
inLoadContext,
inDefer=False):
if node.type in ('file', 'function', 'catch'):
top_scope = node.scope
else:
top_scope = scopes.find_enclosing(
node) # get enclosing scope of node
for scope in top_scope.scope_iterator(
): # walk through this and all nested scopes
for global_name, scopeVar in scope.globals().items(
): # get the global symbols { sym_name: ScopeVar }
for var_node in scopeVar.uses: # create a depsItem for all its uses
if treeutil.hasAncestor(
var_node, node
): # var_node is not disconnected through optimization
depsItem = self.qualify_deps_item(
var_node, scope.is_load_time, scope.is_defer)
# as this also does filtering
if depsItem:
depsList.append(depsItem) # and qualify them
#if depsItem.name == "qx.log.appender.Console":
# import pydb; pydb.debugger()
# Augment with feature dependencies introduces with qx.core.Environment.get("...") calls
for env_operand in variantoptimizer.findVariantNodes(node):
call_node = env_operand.parent.parent
env_key = call_node.getChild("arguments").children[0].get(
"value", "")
className, classAttribute = self.getClassNameFromEnvKey(env_key)
if className:
#print className
depsItem = DependencyItem(className, classAttribute, self.id,
env_operand.get('line', -1))
depsItem.isCall = True # treat as if actual call, to collect recursive deps
# .inLoadContext
# get 'qx' node of 'qx.core.Environment....'
qx_idnode = treeutil.findFirstChainChild(env_operand)
scope = qx_idnode.scope
inLoadContext = scope.is_load_time # get its scope's .is_load_time
depsItem.isLoadDep = inLoadContext
if inLoadContext:
depsItem.needsRecursion = True
depsList.append(depsItem)
return
def dependencies_from_envcalls(self, node):
depsList = []
qcEnvClass = ClassesAll['qx.core.Environment']
for env_operand in variantoptimizer.findVariantNodes(node):
call_node = env_operand.parent.parent
env_key = call_node.getChild("arguments").children[0].get("value", "")
className, classAttribute = qcEnvClass.classNameFromEnvKey(env_key)
if className and className in ClassesAll:
#print className
depsItem = DependencyItem(className, classAttribute, self.id, env_operand.get('line', -1))
depsItem.isCall = True # treat as if actual call, to collect recursive deps
# .inLoadContext
qx_idnode = treeutil.findFirstChainChild(env_operand) # 'qx' node of 'qx.core.Environment....'
scope = qx_idnode.scope
depsItem.isLoadDep = scope.is_load_time
if depsItem.isLoadDep:
depsItem.needsRecursion = True
depsList.append(depsItem)
return depsList
def dependencies_from_envcalls(self, node):
depsList = []
if 'qx.core.Environment' not in ClassesAll:
self.context['console'].warn("No qx.core.Environment available to extract feature keys from")
return depsList
qcEnvClass = ClassesAll['qx.core.Environment']
for env_operand in variantoptimizer.findVariantNodes(node):
call_node = env_operand.parent.parent
env_key = call_node.getChild("arguments").children[0].get("value", "")
# Without qx.core.Environment._checksMap:
# ---------------------------------------
className = qcEnvClass.classNameFromEnvKeyByIndex(env_key)
if className and className in ClassesAll:
#print className
depsItem = DependencyItem(className, "", self.id, env_operand.get('line', -1))
depsItem.isCall = True # treat as if actual call, to collect recursive deps
depsItem.node = call_node
# .inLoadContext
qx_idnode = treeutil.findFirstChainChild(env_operand) # 'qx' node of 'qx.core.Environment....'
scope = qx_idnode.scope
depsItem.isLoadDep = scope.is_load_time
if depsItem.isLoadDep:
depsItem.needsRecursion = True
depsList.append(depsItem)
# With qx.core.Environment._checksMap:
# ------------------------------------
# className, classAttribute = qcEnvClass.classNameFromEnvKey(env_key)
# if className and className in ClassesAll:
# #print className
# depsItem = DependencyItem(className, classAttribute, self.id, env_operand.get('line', -1))
# depsItem.isCall = True # treat as if actual call, to collect recursive deps
# depsItem.node = call_node
# # .inLoadContext
# qx_idnode = treeutil.findFirstChainChild(env_operand) # 'qx' node of 'qx.core.Environment....'
# scope = qx_idnode.scope
# depsItem.isLoadDep = scope.is_load_time
# if depsItem.isLoadDep:
# depsItem.needsRecursion = True
# depsList.append(depsItem)
return depsList
def _analyzeClassDepsNode_2(self, node, depsList, inLoadContext, inDefer=False):
if node.type in ('file', 'function', 'catch'):
top_scope = node.scope
else:
top_scope = scopes.find_enclosing(node) # get enclosing scope of node
for scope in top_scope.scope_iterator(): # walk through this and all nested scopes
for global_name, scopeVar in scope.globals().items(): # get the global symbols { sym_name: ScopeVar }
for var_node in scopeVar.uses: # create a depsItem for all its uses
if treeutil.hasAncestor(var_node, node): # var_node is not disconnected through optimization
depsItem = self.qualify_deps_item(var_node, scope.is_load_time, scope.is_defer)
# as this also does filtering
if depsItem:
depsList.append(depsItem) # and qualify them
#if depsItem.name == "qx.log.appender.Console":
# import pydb; pydb.debugger()
# Augment with feature dependencies introduces with qx.core.Environment.get("...") calls
for env_operand in variantoptimizer.findVariantNodes(node):
call_node = env_operand.parent.parent
env_key = call_node.getChild("arguments").children[0].get("value", "")
className, classAttribute = self.getClassNameFromEnvKey(env_key)
if className:
#print className
depsItem = DependencyItem(className, classAttribute, self.id, env_operand.get('line', -1))
depsItem.isCall = True # treat as if actual call, to collect recursive deps
# .inLoadContext
# get 'qx' node of 'qx.core.Environment....'
qx_idnode = treeutil.findFirstChainChild(env_operand)
scope = qx_idnode.scope
inLoadContext = scope.is_load_time # get its scope's .is_load_time
depsItem.isLoadDep = inLoadContext
if inLoadContext:
depsItem.needsRecursion = True
depsList.append(depsItem)
return
