public PropertySymbol CreateProperty(Name name, ParentSymbol parent)
{
PropertySymbol sym = newBasicSym(SYMKIND.SK_PropertySymbol, name, parent) as PropertySymbol;
Debug.Assert(sym != null);
return(sym);
}
public EventSymbol CreateEvent(Name name, ParentSymbol parent)
{
EventSymbol sym = newBasicSym(SYMKIND.SK_EventSymbol, name, parent) as EventSymbol;
Debug.Assert(sym != null);
return(sym);
}
public MethodSymbol CreateMethod(Name name, ParentSymbol parent, AggregateDeclaration declaration)
{
MethodSymbol sym = newBasicSym(SYMKIND.SK_MethodSymbol, name, parent).AsMethodSymbol();
sym.declaration = declaration;
return(sym);
}
public PropertySymbol CreateProperty(Name name, ParentSymbol parent, AggregateDeclaration declaration)
{
PropertySymbol sym = newBasicSym(SYMKIND.SK_PropertySymbol, name, parent).AsPropertySymbol();
sym.declaration = declaration;
Debug.Assert(sym != null);
return(sym);
}
// Members of aggs
public FieldSymbol CreateMemberVar(Name name, ParentSymbol parent)
{
Debug.Assert(name != null);
FieldSymbol sym = newBasicSym(SYMKIND.SK_FieldSymbol, name, parent) as FieldSymbol;
Debug.Assert(sym != null);
return(sym);
}
public void InsertChild(ParentSymbol parent, Symbol child)
{
Debug.Assert(child.nextSameName == null);
Debug.Assert(child.parent == null || child.parent == parent);
child.parent = parent;
// Place the child into the hash table.
InsertChildNoGrow(child);
}
public AssemblyQualifiedNamespaceSymbol CreateNamespaceAid(Name name, ParentSymbol parent, KAID assemblyID)
{
Debug.Assert(name != null);
AssemblyQualifiedNamespaceSymbol sym = newBasicSym(SYMKIND.SK_AssemblyQualifiedNamespaceSymbol, name, parent).AsAssemblyQualifiedNamespaceSymbol();
Debug.Assert(sym != null);
return(sym);
}
public static void InsertChild(ParentSymbol parent, Symbol child)
{
Debug.Assert(child.nextSameName == null);
Debug.Assert(child.parent == null || child.parent == parent);
child.parent = parent;
// Place the child into the hash table.
InsertChildNoGrow(child);
}
public AssemblyQualifiedNamespaceSymbol CreateNamespaceAid(Name name, ParentSymbol parent, KAID assemblyID)
{
Debug.Assert(name != null);
AssemblyQualifiedNamespaceSymbol sym = newBasicSym(SYMKIND.SK_AssemblyQualifiedNamespaceSymbol, name, parent).AsAssemblyQualifiedNamespaceSymbol();
Debug.Assert(sym != null);
return sym;
}
public bool Lookup(CType typeSrc, Expr obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.Type != null);
Debug.Assert(typeSrc is AggregateType);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_typeSrc = typeSrc;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
_typeQual = (_flags & MemLookFlags.Ctor) != 0 ? _typeSrc : obj?.Type;
// Determine what to search.
AggregateType typeCls1;
AggregateType typeIface;
TypeArray ifaces;
if (typeSrc.IsInterfaceType)
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeCls1 = null;
typeIface = (AggregateType)typeSrc;
ifaces = typeIface.IfacesAll;
}
else
{
typeCls1 = (AggregateType)typeSrc;
typeIface = null;
ifaces = TypeArray.Empty;
}
AggregateType typeCls2 = typeIface != null || ifaces.Count > 0
? SymbolLoader.GetPredefindType(PredefinedType.PT_OBJECT)
: null;
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.Count > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.IsPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
return(!FError());
}
public IndexerSymbol CreateIndexer(Name name, ParentSymbol parent, Name realName, AggregateDeclaration declaration)
{
IndexerSymbol sym = (IndexerSymbol)newBasicSym(SYMKIND.SK_IndexerSymbol, name, parent);
sym.setKind(SYMKIND.SK_PropertySymbol);
sym.isOperator = true;
sym.declaration = declaration;
Debug.Assert(sym != null);
return sym;
}
public IndexerSymbol CreateIndexer(Name name, ParentSymbol parent, Name realName)
{
IndexerSymbol sym = (IndexerSymbol)newBasicSym(SYMKIND.SK_IndexerSymbol, name, parent);
sym.setKind(SYMKIND.SK_PropertySymbol);
sym.isOperator = true;
Debug.Assert(sym != null);
return(sym);
}
public LocalVariableSymbol CreateLocalVar(Name name, ParentSymbol parent, CType type)
{
LocalVariableSymbol sym = newBasicSym(SYMKIND.SK_LocalVariableSymbol, name, parent).AsLocalVariableSymbol();
sym.SetType(type);
sym.SetAccess(ACCESS.ACC_UNKNOWN); // required for Symbol::hasExternalAccess which is used by refactoring
sym.wrap = null;
return(sym);
}
// Members of aggs
public FieldSymbol CreateMemberVar(Name name, ParentSymbol parent, AggregateDeclaration declaration, int iIteratorLocal)
{
Debug.Assert(name != null);
FieldSymbol sym = newBasicSym(SYMKIND.SK_FieldSymbol, name, parent).AsFieldSymbol();
sym.declaration = declaration;
Debug.Assert(sym != null);
return(sym);
}
public Symbol LookupSym(Name name, ParentSymbol parent, symbmask_t kindmask)
{
Key k = new Key(name, parent);
Symbol sym;
if (_dictionary.TryGetValue(k, out sym))
{
return FindCorrectKind(sym, kindmask);
}
return null;
}
public Symbol LookupSym(Name name, ParentSymbol parent, symbmask_t kindmask)
{
Key k = new Key(name, parent);
Symbol sym;
if (_dictionary.TryGetValue(k, out sym))
{
return(FindCorrectKind(sym, kindmask));
}
return(null);
}
public static IEnumerable <Symbol> Children(this ParentSymbol symbol)
{
if (symbol == null)
{
yield break;
}
Symbol current = symbol.firstChild;
while (current != null)
{
yield return(current);
current = current.nextChild;
}
}
public AggregateSymbol CreateUnresolvedAggregate(Name name, ParentSymbol parent, TypeManager typeManager)
{
Debug.Assert(name != null);
Symbol sym = newBasicSym(SYMKIND.SK_UnresolvedAggregateSymbol, name, parent);
AggregateSymbol AggregateSymbol = null;
// Unresolved Aggs need extra storage, but are still considered Aggs.
sym.setKind(SYMKIND.SK_AggregateSymbol);
AggregateSymbol = sym.AsAggregateSymbol();
AggregateSymbol.SetTypeManager(typeManager);
Debug.Assert(AggregateSymbol != null);
return(AggregateSymbol);
}
public AggregateSymbol CreateUnresolvedAggregate(Name name, ParentSymbol parent, TypeManager typeManager)
{
Debug.Assert(name != null);
Symbol sym = newBasicSym(SYMKIND.SK_UnresolvedAggregateSymbol, name, parent);
AggregateSymbol AggregateSymbol = null;
// Unresolved Aggs need extra storage, but are still considered Aggs.
sym.setKind(SYMKIND.SK_AggregateSymbol);
AggregateSymbol = sym.AsAggregateSymbol();
AggregateSymbol.SetTypeManager(typeManager);
Debug.Assert(AggregateSymbol != null);
return (AggregateSymbol);
}
public static Symbol LookupNextSym(Symbol sym, ParentSymbol parent, symbmask_t kindmask)
{
Debug.Assert(sym.parent == parent);
sym = sym.nextSameName;
Debug.Assert(sym == null || sym.parent == parent);
// Keep traversing the list of symbols with same name and parent.
while (sym != null)
{
if ((kindmask & sym.mask()) > 0)
{
return(sym);
}
sym = sym.nextSameName;
Debug.Assert(sym == null || sym.parent == parent);
}
return(null);
}
private Symbol NewBasicSymbol(
SYMKIND kind,
Name name,
ParentSymbol parent)
{
Symbol sym;
switch (kind)
{
case SYMKIND.SK_NamespaceSymbol:
sym = new NamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateSymbol:
sym = new AggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateDeclaration:
sym = new AggregateDeclaration();
sym.name = name;
break;
case SYMKIND.SK_TypeParameterSymbol:
sym = new TypeParameterSymbol();
sym.name = name;
break;
case SYMKIND.SK_FieldSymbol:
sym = new FieldSymbol();
sym.name = name;
break;
case SYMKIND.SK_LocalVariableSymbol:
sym = new LocalVariableSymbol();
sym.name = name;
break;
case SYMKIND.SK_MethodSymbol:
sym = new MethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_PropertySymbol:
sym = new PropertySymbol();
sym.name = name;
break;
case SYMKIND.SK_EventSymbol:
sym = new EventSymbol();
sym.name = name;
break;
case SYMKIND.SK_Scope:
sym = new Scope();
sym.name = name;
break;
case SYMKIND.SK_IndexerSymbol:
sym = new IndexerSymbol();
sym.name = name;
break;
default:
throw Error.InternalCompilerError();
}
sym.setKind(kind);
if (parent != null)
{
// Set the parent element of the child symbol.
parent.AddToChildList(sym);
_symbolTable.InsertChild(parent, sym);
}
return(sym);
}
/***************************************************************************************************
* Lookup must be called before anything else can be called.
*
* typeSrc - Must be an AggregateType or TypeParameterType.
* obj - the expression through which the member is being accessed. This is used for accessibility
* of protected members and for constructing a MEMGRP from the results of the lookup.
* It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
* will not be used for MEMGRP construction.
* symWhere - the symbol from with the name is being accessed (for checking accessibility).
* name - the name to look for.
* arity - the number of type args specified. Only members that support this arity are found.
* Note that when arity is zero, all methods are considered since we do type argument
* inferencing.
*
* flags - See MemLookFlags.
* TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, Expr obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.Type != null);
Debug.Assert(typeSrc is AggregateType);
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.SymbolLoader;
_typeSrc = typeSrc;
_obj = obj is ExprClass ? null : obj;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
_typeQual = (_flags & MemLookFlags.Ctor) != 0 ? _typeSrc : obj?.Type;
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (!typeSrc.IsInterfaceType)
{
typeCls1 = (AggregateType)typeSrc;
if (typeCls1.IsWindowsRuntimeType)
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = (AggregateType)typeSrc;
ifaces = typeIface.IfacesAll;
}
if (typeIface != null || ifaces.Count > 0)
{
typeCls2 = GetSymbolLoader().GetPredefindType(PredefinedType.PT_OBJECT);
}
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.Count > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.IsPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
return(!FError());
}
public Key(Name name, ParentSymbol parent)
{
_name = name;
_parent = parent;
}
public MethodSymbol CreateMethod(Name name, ParentSymbol parent, AggregateDeclaration declaration)
{
MethodSymbol sym = newBasicSym(SYMKIND.SK_MethodSymbol, name, parent).AsMethodSymbol();
sym.declaration = declaration;
return sym;
}
public PropertySymbol CreateProperty(Name name, ParentSymbol parent, AggregateDeclaration declaration)
{
PropertySymbol sym = newBasicSym(SYMKIND.SK_PropertySymbol, name, parent).AsPropertySymbol();
Debug.Assert(sym != null);
sym.declaration = declaration;
return (sym);
}
/***************************************************************************************************
Lookup must be called before anything else can be called.
typeSrc - Must be an AggregateType or TypeParameterType.
obj - the expression through which the member is being accessed. This is used for accessibility
of protected members and for constructing a MEMGRP from the results of the lookup.
It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
will not be used for MEMGRP construction.
symWhere - the symbol from with the name is being accessed (for checking accessibility).
name - the name to look for.
arity - the number of type args specified. Only members that support this arity are found.
Note that when arity is zero, all methods are considered since we do type argument
inferencing.
flags - See MemLookFlags.
TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, EXPR obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.type != null);
Debug.Assert(typeSrc.IsAggregateType() || typeSrc.IsTypeParameterType());
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.GetSymbolLoader();
_typeSrc = typeSrc;
_obj = (obj != null && !obj.isCLASS()) ? obj : null;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
if ((_flags & MemLookFlags.BaseCall) != 0)
_typeQual = null;
else if ((_flags & MemLookFlags.Ctor) != 0)
_typeQual = _typeSrc;
else if (obj != null)
_typeQual = (CType)obj.type;
else
_typeQual = null;
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (typeSrc.IsTypeParameterType())
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall | MemLookFlags.TypeVarsAllowed)) == 0);
_flags &= ~MemLookFlags.TypeVarsAllowed;
ifaces = typeSrc.AsTypeParameterType().GetInterfaceBounds();
typeCls1 = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
if (ifaces.size > 0 && typeCls1.isPredefType(PredefinedType.PT_OBJECT))
typeCls1 = null;
}
else if (!typeSrc.isInterfaceType())
{
typeCls1 = typeSrc.AsAggregateType();
if (typeCls1.IsWindowsRuntimeType())
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert(typeSrc.isInterfaceType());
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = typeSrc.AsAggregateType();
ifaces = typeIface.GetIfacesAll();
}
if (typeIface != null || ifaces.size > 0)
typeCls2 = GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.size > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.isPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
// if we are requested with extension methods
_results = new CMemberLookupResults(GetAllTypes(), _name);
return !FError();
}
protected Symbol newBasicSym(
SYMKIND kind,
Name name,
ParentSymbol parent)
{
// The parser creates names with PN_MISSING when attempting to recover from errors
// To prevent spurious errors, we create SYMs with a different name (PN_MISSINGSYM)
// so that they are never found when doing lookup.
if (name == m_pMissingNameNode)
{
name = m_pMissingNameSym;
}
Symbol sym;
switch (kind)
{
case SYMKIND.SK_NamespaceSymbol:
sym = new NamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_NamespaceDeclaration:
sym = new NamespaceDeclaration();
sym.name = name;
break;
case SYMKIND.SK_AssemblyQualifiedNamespaceSymbol:
sym = new AssemblyQualifiedNamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateSymbol:
sym = new AggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateDeclaration:
sym = new AggregateDeclaration();
sym.name = name;
break;
case SYMKIND.SK_TypeParameterSymbol:
sym = new TypeParameterSymbol();
sym.name = name;
break;
case SYMKIND.SK_FieldSymbol:
sym = new FieldSymbol();
sym.name = name;
break;
case SYMKIND.SK_LocalVariableSymbol:
sym = new LocalVariableSymbol();
sym.name = name;
break;
case SYMKIND.SK_MethodSymbol:
sym = new MethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_PropertySymbol:
sym = new PropertySymbol();
sym.name = name;
break;
case SYMKIND.SK_EventSymbol:
sym = new EventSymbol();
sym.name = name;
break;
case SYMKIND.SK_TransparentIdentifierMemberSymbol:
sym = new TransparentIdentifierMemberSymbol();
sym.name = name;
break;
case SYMKIND.SK_Scope:
sym = new Scope();
sym.name = name;
break;
case SYMKIND.SK_LabelSymbol:
sym = new LabelSymbol();
sym.name = name;
break;
case SYMKIND.SK_GlobalAttributeDeclaration:
sym = new GlobalAttributeDeclaration();
sym.name = name;
break;
case SYMKIND.SK_UnresolvedAggregateSymbol:
sym = new UnresolvedAggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_InterfaceImplementationMethodSymbol:
sym = new InterfaceImplementationMethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_IndexerSymbol:
sym = new IndexerSymbol();
sym.name = name;
break;
case SYMKIND.SK_ParentSymbol:
sym = new ParentSymbol();
sym.name = name;
break;
case SYMKIND.SK_IteratorFinallyMethodSymbol:
sym = new IteratorFinallyMethodSymbol();
sym.name = name;
break;
default:
throw Error.InternalCompilerError();
}
sym.setKind(kind);
if (parent != null)
{
// Set the parent element of the child symbol.
parent.AddToChildList(sym);
m_pSymTable.InsertChild(parent, sym);
}
return (sym);
}
public Symbol LookupGlobalSymCore(Name name, ParentSymbol parent, symbmask_t kindmask)
{
return(tableGlobal.LookupSym(name, parent, kindmask));
}
public static Symbol LookupSym(Name name, ParentSymbol parent, symbmask_t kindmask)
{
RuntimeBinder.EnsureLockIsTaken();
return(s_dictionary.TryGetValue(new Key(name, parent), out Symbol sym) ? FindCorrectKind(sym, kindmask) : null);
}
// Members of aggs
public FieldSymbol CreateMemberVar(Name name, ParentSymbol parent, AggregateDeclaration declaration, int iIteratorLocal)
{
Debug.Assert(name != null);
FieldSymbol sym = newBasicSym(SYMKIND.SK_FieldSymbol, name, parent).AsFieldSymbol();
sym.declaration = declaration;
Debug.Assert(sym != null);
return (sym);
}
/***************************************************************************************************
* Lookup must be called before anything else can be called.
*
* typeSrc - Must be an AggregateType or TypeParameterType.
* obj - the expression through which the member is being accessed. This is used for accessibility
* of protected members and for constructing a MEMGRP from the results of the lookup.
* It is legal for obj to be an EK_CLASS, in which case it may be used for accessibility, but
* will not be used for MEMGRP construction.
* symWhere - the symbol from with the name is being accessed (for checking accessibility).
* name - the name to look for.
* arity - the number of type args specified. Only members that support this arity are found.
* Note that when arity is zero, all methods are considered since we do type argument
* inferencing.
*
* flags - See MemLookFlags.
* TypeVarsAllowed only applies to the most derived type (not base types).
***************************************************************************************************/
public bool Lookup(CSemanticChecker checker, CType typeSrc, EXPR obj, ParentSymbol symWhere, Name name, int arity, MemLookFlags flags)
{
Debug.Assert((flags & ~MemLookFlags.All) == 0);
Debug.Assert(obj == null || obj.type != null);
Debug.Assert(typeSrc.IsAggregateType() || typeSrc.IsTypeParameterType());
Debug.Assert(checker != null);
_prgtype = _rgtypeStart;
// Save the inputs for error handling, etc.
_pSemanticChecker = checker;
_pSymbolLoader = checker.GetSymbolLoader();
_typeSrc = typeSrc;
_obj = (obj != null && !obj.isCLASS()) ? obj : null;
_symWhere = symWhere;
_name = name;
_arity = arity;
_flags = flags;
if ((_flags & MemLookFlags.BaseCall) != 0)
{
_typeQual = null;
}
else if ((_flags & MemLookFlags.Ctor) != 0)
{
_typeQual = _typeSrc;
}
else if (obj != null)
{
_typeQual = (CType)obj.type;
}
else
{
_typeQual = null;
}
// Determine what to search.
AggregateType typeCls1 = null;
AggregateType typeIface = null;
TypeArray ifaces = BSYMMGR.EmptyTypeArray();
AggregateType typeCls2 = null;
if (typeSrc.IsTypeParameterType())
{
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall | MemLookFlags.TypeVarsAllowed)) == 0);
_flags &= ~MemLookFlags.TypeVarsAllowed;
ifaces = typeSrc.AsTypeParameterType().GetInterfaceBounds();
typeCls1 = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
if (ifaces.size > 0 && typeCls1.isPredefType(PredefinedType.PT_OBJECT))
{
typeCls1 = null;
}
}
else if (!typeSrc.isInterfaceType())
{
typeCls1 = typeSrc.AsAggregateType();
if (typeCls1.IsWindowsRuntimeType())
{
ifaces = typeCls1.GetWinRTCollectionIfacesAll(GetSymbolLoader());
}
}
else
{
Debug.Assert(typeSrc.isInterfaceType());
Debug.Assert((_flags & (MemLookFlags.Ctor | MemLookFlags.NewObj | MemLookFlags.Operator | MemLookFlags.BaseCall)) == 0);
typeIface = typeSrc.AsAggregateType();
ifaces = typeIface.GetIfacesAll();
}
if (typeIface != null || ifaces.size > 0)
{
typeCls2 = GetSymbolLoader().GetReqPredefType(PredefinedType.PT_OBJECT);
}
// Search the class first (except possibly object).
if (typeCls1 == null || LookupInClass(typeCls1, ref typeCls2))
{
// Search the interfaces.
if ((typeIface != null || ifaces.size > 0) && LookupInInterfaces(typeIface, ifaces) && typeCls2 != null)
{
// Search object last.
Debug.Assert(typeCls2 != null && typeCls2.isPredefType(PredefinedType.PT_OBJECT));
AggregateType result = null;
LookupInClass(typeCls2, ref result);
}
}
// if we are requested with extension methods
_results = new CMemberLookupResults(GetAllTypes(), _name);
return(!FError());
}
public MethodSymbol CreateMethod(Name name, ParentSymbol parent)
{
MethodSymbol sym = newBasicSym(SYMKIND.SK_MethodSymbol, name, parent).AsMethodSymbol();
return(sym);
}
public Key(Name name, ParentSymbol parent)
{
_name = name;
_parent = parent;
}
public Symbol LookupNextSym(Symbol sym, ParentSymbol parent, symbmask_t kindmask)
{
return BSYMMGR.LookupNextSym(sym, parent, kindmask);
}
public Symbol LookupNextSym(Symbol sym, ParentSymbol parent, symbmask_t kindmask)
{
return(BSYMMGR.LookupNextSym(sym, parent, kindmask));
}
public Key(Name name, ParentSymbol parent)
{
this.name = name;
this.parent = parent;
}
public static Symbol LookupNextSym(Symbol sym, ParentSymbol parent, symbmask_t kindmask) => BSYMMGR.LookupNextSym(sym, parent, kindmask);
protected Symbol newBasicSym(
SYMKIND kind,
Name name,
ParentSymbol parent)
{
// The parser creates names with PN_MISSING when attempting to recover from errors
// To prevent spurious errors, we create SYMs with a different name (PN_MISSINGSYM)
// so that they are never found when doing lookup.
if (name == m_pMissingNameNode)
{
name = m_pMissingNameSym;
}
Symbol sym;
switch (kind)
{
case SYMKIND.SK_NamespaceSymbol:
sym = new NamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_NamespaceDeclaration:
sym = new NamespaceDeclaration();
sym.name = name;
break;
case SYMKIND.SK_AssemblyQualifiedNamespaceSymbol:
sym = new AssemblyQualifiedNamespaceSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateSymbol:
sym = new AggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_AggregateDeclaration:
sym = new AggregateDeclaration();
sym.name = name;
break;
case SYMKIND.SK_TypeParameterSymbol:
sym = new TypeParameterSymbol();
sym.name = name;
break;
case SYMKIND.SK_FieldSymbol:
sym = new FieldSymbol();
sym.name = name;
break;
case SYMKIND.SK_LocalVariableSymbol:
sym = new LocalVariableSymbol();
sym.name = name;
break;
case SYMKIND.SK_MethodSymbol:
sym = new MethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_PropertySymbol:
sym = new PropertySymbol();
sym.name = name;
break;
case SYMKIND.SK_EventSymbol:
sym = new EventSymbol();
sym.name = name;
break;
case SYMKIND.SK_TransparentIdentifierMemberSymbol:
sym = new TransparentIdentifierMemberSymbol();
sym.name = name;
break;
case SYMKIND.SK_Scope:
sym = new Scope();
sym.name = name;
break;
case SYMKIND.SK_LabelSymbol:
sym = new LabelSymbol();
sym.name = name;
break;
case SYMKIND.SK_GlobalAttributeDeclaration:
sym = new GlobalAttributeDeclaration();
sym.name = name;
break;
case SYMKIND.SK_UnresolvedAggregateSymbol:
sym = new UnresolvedAggregateSymbol();
sym.name = name;
break;
case SYMKIND.SK_InterfaceImplementationMethodSymbol:
sym = new InterfaceImplementationMethodSymbol();
sym.name = name;
break;
case SYMKIND.SK_IndexerSymbol:
sym = new IndexerSymbol();
sym.name = name;
break;
case SYMKIND.SK_ParentSymbol:
sym = new ParentSymbol();
sym.name = name;
break;
case SYMKIND.SK_IteratorFinallyMethodSymbol:
sym = new IteratorFinallyMethodSymbol();
sym.name = name;
break;
default:
throw Error.InternalCompilerError();
}
sym.setKind(kind);
if (parent != null)
{
// Set the parent element of the child symbol.
parent.AddToChildList(sym);
m_pSymTable.InsertChild(parent, sym);
}
return(sym);
}
public MethodSymbol CreateMethod(Name name, ParentSymbol parent) => newBasicSym(SYMKIND.SK_MethodSymbol, name, parent) as MethodSymbol;
public EventSymbol CreateEvent(Name name, ParentSymbol parent, AggregateDeclaration declaration)
{
EventSymbol sym = newBasicSym(SYMKIND.SK_EventSymbol, name, parent).AsEventSymbol();
sym.declaration = declaration;
Debug.Assert(sym != null);
return (sym);
}
public LocalVariableSymbol CreateLocalVar(Name name, ParentSymbol parent, CType type)
{
LocalVariableSymbol sym = newBasicSym(SYMKIND.SK_LocalVariableSymbol, name, parent).AsLocalVariableSymbol();
sym.SetType(type);
sym.SetAccess(ACCESS.ACC_UNKNOWN); // required for Symbol::hasExternalAccess which is used by refactoring
sym.wrap = null;
return sym;
}
/////////////////////////////////////////////////////////////////////////////////
internal SymWithType LookupMember(
string name,
EXPR callingObject,
ParentSymbol context,
int arity,
MemberLookup mem,
bool allowSpecialNames,
bool requireInvocable)
{
CType type = callingObject.type;
if (type.IsArrayType())
{
type = _semanticChecker.GetSymbolLoader().GetReqPredefType(PredefinedType.PT_ARRAY);
}
if (type.IsNullableType())
{
type = type.AsNullableType().GetAts(_semanticChecker.GetSymbolLoader().GetErrorContext());
}
if (!mem.Lookup(
_semanticChecker,
type,
callingObject,
context,
GetName(name),
arity,
MemLookFlags.TypeVarsAllowed |
(allowSpecialNames ? 0 : MemLookFlags.UserCallable) |
(name == SpecialNames.Indexer ? MemLookFlags.Indexer : 0) |
(name == SpecialNames.Constructor ? MemLookFlags.Ctor : 0) |
(requireInvocable ? MemLookFlags.MustBeInvocable : 0)))
{
return null;
}
return mem.SwtFirst();
}
public static Symbol LookupSym(Name name, ParentSymbol parent, symbmask_t kindmask) => s_dictionary.TryGetValue(new Key(name, parent), out Symbol sym) ? FindCorrectKind(sym, kindmask) : null;