public NamespaceNode(Token token, NameNode nameNode,
ParseNodeList externAliases,
ParseNodeList usingClauses,
ParseNodeList members)
: base(ParseNodeType.Namespace, token) {
_name = nameNode.Name;
_externAliases = GetParentedNodeList(externAliases);
_usingClauses = GetParentedNodeList(usingClauses);
_members = GetParentedNodeList(members);
}
public PropertyDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType,
AtomicNameNode name,
AccessorNode getOrRemove,
AccessorNode setOrAdd)
: this(ParseNodeType.PropertyDeclaration, token, attributes, modifiers, type, interfaceType, getOrRemove, setOrAdd) {
_name = (AtomicNameNode)GetParentedNode(name);
}
public IndexerDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType,
ParseNodeList parameters,
AccessorNode get,
AccessorNode set)
: base(ParseNodeType.IndexerDeclaration, token, attributes, modifiers, type, interfaceType, get, set)
{
_parameters = GetParentedNodeList(parameters);
}
public MethodDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode returnType,
NameNode interfaceType,
AtomicNameNode name,
ParseNodeList typeParameters,
ParseNodeList formals,
ParseNodeList constraints,
BlockStatementNode body)
: this(ParseNodeType.MethodDeclaration, token, attributes, modifiers, returnType, name, formals, body) {
_interfaceType = (NameNode)GetParentedNode(interfaceType);
_typeParameters = GetParentedNodeList(typeParameters);
_constraints = GetParentedNodeList(constraints);
}
protected PropertyDeclarationNode(ParseNodeType nodeType, Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType,
AccessorNode getOrRemove,
AccessorNode setOrAdd)
: base(nodeType, token) {
_attributes = GetParentedNodeList(AttributeNode.GetAttributeList(attributes));
_modifiers = modifiers;
_type = GetParentedNode(type);
_interfaceType = (NameNode)GetParentedNode(interfaceType);
_getOrRemove = (AccessorNode)GetParentedNode(getOrRemove);
_setOrAdd = (AccessorNode)GetParentedNode(setOrAdd);
}
public UsingAliasNode(Token token, AtomicNameNode name, NameNode type)
: base(ParseNodeType.UsingAlias, token)
{
_aliasName = (AtomicNameNode)GetParentedNode(name);
_typeName = (NameNode)GetParentedNode(type);
}
public UsingNamespaceNode(Token token, NameNode namespaceName)
: base(ParseNodeType.UsingNamespace, token)
{
_namespaceNameNode = (NameNode)GetParentedNode(namespaceName);
}
public UsingAliasNode(Token token, AtomicNameNode name, NameNode type)
: base(ParseNodeType.UsingAlias, token)
{
_aliasName = (AtomicNameNode)GetParentedNode(name);
_typeName = (NameNode)GetParentedNode(type);
}
public ExternAliasNode(Token token, AtomicNameNode aliasName)
: base(ParseNodeType.ExternAlias, token)
{
_aliasName = (AtomicNameNode)GetParentedNode(aliasName);
}
public AttributeNode(NameNode typeName, ParseNode arguments)
: base(ParseNodeType.Attribute, typeName.token)
{
_typeName = (NameNode)GetParentedNode(typeName);
_arguments = GetParentedNode(arguments);
}
public AttributeNode(NameNode typeName, ParseNode arguments)
: base(ParseNodeType.Attribute, typeName.token)
{
_typeName = (NameNode)GetParentedNode(typeName);
_arguments = GetParentedNode(arguments);
}
// this
// type-name.this
// methodName (
// methodName<T> (
// typename.methodName (
// propertyName {
// typename.propertyName {
// typename.methodName<[Attr]T> (
// fieldName
private ScanMemberNameKind ParseMemberName(out NameNode interfaceType) {
if (PeekType() == TokenType.Operator) {
interfaceType = null;
return ScanMemberNameKind.Operator;
}
Token token = PeekToken();
ParseNodeList list = new ParseNodeList();
if (PeekType() == TokenType.Identifier && PeekType(1) == TokenType.ColonColon) {
interfaceType = ParseAliasQualifiedName(false);
list.Append(interfaceType);
EatDotOrColonColon();
}
else {
interfaceType = null;
}
ScanMemberNameKind result = ScanMemberNameKind.Invalid;
do {
if (PeekType() == TokenType.This)
result = ScanMemberNameKind.Indexer;
else if (PeekType() != TokenType.Identifier)
result = ScanMemberNameKind.Field;
else {
switch (PeekType(1)) {
case TokenType.OpenCurly:
result = ScanMemberNameKind.Property;
break;
case TokenType.OpenParen:
result = ScanMemberNameKind.Method;
break;
case TokenType.OpenAngle:
int mark = Mark();
NextToken(); // _id
TypeArgumentListScan scan = ScanTypeArgumentListOpt();
if (scan == TypeArgumentListScan.MayBeTypeArgumentList) {
switch (PeekType()) {
case TokenType.Dot:
case TokenType.ColonColon:
scan = TypeArgumentListScan.MustBeTypeArgumentList;
break;
default:
scan = TypeArgumentListScan.TypeParameterList;
break;
}
}
Rewind(mark);
if (scan == TypeArgumentListScan.TypeParameterList || scan == TypeArgumentListScan.NotTypeArgumentList) {
result = ScanMemberNameKind.Method;
break;
}
list.Append(ParseSimpleName(false));
EatDotOrColonColon();
break;
case TokenType.ColonColon:
case TokenType.Dot:
list.Append(ParseSimpleName(false));
EatDotOrColonColon();
break;
default:
result = ScanMemberNameKind.Field;
break;
}
}
} while (ScanMemberNameKind.Invalid == result);
if (list.Count > 1)
interfaceType = new MultiPartNameNode(token, list);
return result;
}
public AliasQualifiedNameNode(AtomicNameNode left, NameNode right)
: base(ParseNodeType.AliasQualifiedName, left.token)
{
_aliasName = (AtomicNameNode)GetParentedNode(left);
_name = (NameNode)GetParentedNode(right);
}
private void ReportInterfaceVariable(NameNode interfaceType) {
if (interfaceType != null) {
ReportError(ParseError.VariableCannotBeInterfaceImpl, interfaceType.token);
}
}
private PropertyDeclarationNode ParseProperty(
Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType,
bool isEvent) {
AtomicNameNode name = ParseIdentifier();
AccessorNode get;
AccessorNode set;
ParseAccessors(isEvent, out get, out set);
return new PropertyDeclarationNode(
token,
attributes,
modifiers,
type,
interfaceType,
name,
get,
set);
}
private IndexerDeclarationNode ParseIndexer(
Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType) {
Eat(TokenType.This);
Eat(TokenType.OpenSquare);
ParseNodeList formals = ParseFormalParameterList(TokenType.CloseSquare);
Eat(TokenType.CloseSquare);
AccessorNode get;
AccessorNode set;
ParseAccessors(false, out get, out set);
return new IndexerDeclarationNode(
token,
attributes,
modifiers,
type,
interfaceType,
formals,
get,
set);
}
private MethodDeclarationNode ParseMethod(
Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType) {
return new MethodDeclarationNode(
token,
attributes,
modifiers,
type,
interfaceType,
ParseIdentifier(),
ParseTypeParametersOpt(),
ParseParensFormalParameterList(),
ParseConstraintClauses(),
ParseBlockOpt());
}
public ExternAliasNode(Token token, AtomicNameNode aliasName)
: base(ParseNodeType.ExternAlias, token)
{
_aliasName = (AtomicNameNode)GetParentedNode(aliasName);
}
public UsingNamespaceNode(Token token, NameNode namespaceName)
: base(ParseNodeType.UsingNamespace, token)
{
_namespaceNameNode = (NameNode)GetParentedNode(namespaceName);
}
private Expression ProcessNameNode(NameNode node) {
return ProcessNameNode(node, SymbolFilter.All);
}
public AliasQualifiedNameNode(AtomicNameNode left, NameNode right)
: base(ParseNodeType.AliasQualifiedName, left.token)
{
_aliasName = (AtomicNameNode)GetParentedNode(left);
_name = (NameNode)GetParentedNode(right);
}
private Expression ProcessNameNode(NameNode node, SymbolFilter filter) {
string name = node.Name;
if (node.NodeType == ParseNodeType.GenericName) {
name = name + "`" + ((GenericNameNode)node).TypeArguments.Count;
}
// TODO: When inside a static method, we should only lookup static members
Symbol symbol = _symbolTable.FindSymbol(name, _symbolContext, filter);
if (symbol is LocalSymbol) {
if (_classContext == ((LocalSymbol)symbol).ValueType) {
SymbolFilter memberMask = SymbolFilter.Public | SymbolFilter.Protected | SymbolFilter.Private |
SymbolFilter.InstanceMembers;
return new LocalExpression((LocalSymbol)symbol, memberMask);
}
else {
return new LocalExpression((LocalSymbol)symbol);
}
}
else if (symbol is MemberSymbol) {
// TODO: Does C# allow access to private/protected members if the type of the member is
// the same as the class context?
MemberSymbol memberSymbol = (MemberSymbol)symbol;
if ((memberSymbol.Visibility & MemberVisibility.Static) != 0) {
return new MemberExpression(new TypeExpression((TypeSymbol)memberSymbol.Parent,
SymbolFilter.Public | SymbolFilter.StaticMembers),
memberSymbol);
}
else {
return new MemberExpression(new ThisExpression(_classContext, /* explicitReference */ false),
memberSymbol);
}
}
else if (symbol is TypeSymbol) {
return TransformTypeSymbol((TypeSymbol)symbol);
}
return null;
}
