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 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); }
// 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()); }
private Expression ProcessNameNode(NameNode node) { return ProcessNameNode(node, SymbolFilter.All); }
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; }