Search in sources :

Example 11 with Name

use of dyvil.lang.Name in project Dyvil by Dyvil.

the class ParameterListParser method parse.

@Override
public void parse(IParserManager pm, IToken token) {
    final int type = token.type();
    switch(this.mode) {
        case DECLARATOR:
            switch(type) {
                case BaseSymbols.SEMICOLON:
                    if (token.isInferred()) {
                        return;
                    }
                    break;
                case DyvilKeywords.LET:
                    this.attributes.addFlag(Modifiers.FINAL);
                // Fallthrough
                case DyvilKeywords.VAR:
                    this.mode = NAME;
                    return;
                case DyvilKeywords.THIS:
                    if (token.next().type() != BaseSymbols.COLON) {
                        pm.report(token, "parameter.identifier");
                        this.mode = SEPARATOR;
                        return;
                    }
                    // this : TYPE
                    this.mode = TYPE_ASCRIPTION;
                    // the colon
                    pm.skip();
                    pm.pushParser(new TypeParser(t -> this.setThisType(t, token, pm)));
                    return;
                case DyvilSymbols.AT:
                    final Annotation annotation = new CodeAnnotation(token.raw());
                    this.attributes.add(annotation);
                    pm.pushParser(new AnnotationParser(annotation));
                    return;
            }
            final Modifier modifier;
            if ((modifier = ModifierParser.parseModifier(token, pm)) != null) {
                this.attributes.add(modifier);
                return;
            }
            if (BaseSymbols.isCloseBracket(type)) {
                pm.popParser(true);
                return;
            }
        // Fallthrough
        case NAME:
            final Name name;
            if (Tokens.isIdentifier(type)) {
                name = token.nameValue();
            } else if (type == BaseSymbols.UNDERSCORE) {
                name = null;
            } else if (Tokens.isKeyword(type)) {
                name = Name.fromRaw(token.stringValue());
            } else {
                if (BaseSymbols.isCloseBracket(type)) {
                    pm.popParser(true);
                }
                if (type == Tokens.EOF) {
                    pm.popParser();
                }
                this.mode = SEPARATOR;
                pm.report(token, "parameter.identifier");
                return;
            }
            this.parameter = this.consumer.createParameter(token.raw(), name, this.type, this.attributes);
            this.mode = INTERNAL_NAME;
            return;
        case INTERNAL_NAME:
            this.mode = VARARGS_AFTER_NAME;
            // overwrite the internal name if necessary
            if (Tokens.isIdentifier(type)) {
                // IDENTIFIER IDENTIFIER : TYPE
                this.parameter.setName(token.nameValue());
                return;
            } else if (type == BaseSymbols.UNDERSCORE) {
                // IDENTIFIER _ : TYPE
                this.parameter.setName(null);
                return;
            }
        // Fallthrough
        case VARARGS_AFTER_NAME:
            if (type == DyvilSymbols.ELLIPSIS) {
                this.flags |= VARARGS;
                this.mode = TYPE_ASCRIPTION;
                return;
            }
        // Fallthrough
        case TYPE_ASCRIPTION:
        case VARARGS_AFTER_POST_TYPE:
            // continue with the remaining cases (DEFAULT_VALUE, PROPERTY, ...).
            if (this.mode == VARARGS_AFTER_POST_TYPE) {
                // case (2)
                if (type == DyvilSymbols.ELLIPSIS) {
                    this.setTypeVarargs();
                    this.mode = DEFAULT_VALUE;
                    return;
                }
            } else /* case (1) */
            if (type == BaseSymbols.COLON) {
                this.mode = VARARGS_AFTER_POST_TYPE;
                final TypeParser parser = new TypeParser(this);
                if (this.hasFlag(LAMBDA_ARROW_END)) {
                    parser.withFlags(TypeParser.IGNORE_LAMBDA);
                }
                pm.pushParser(parser);
                return;
            }
        // Fallthrough
        case DEFAULT_VALUE:
            if (type == BaseSymbols.EQUALS) {
                this.mode = PROPERTY;
                pm.pushParser(new ExpressionParser(this.parameter));
                return;
            }
        // Fallthrough
        case PROPERTY:
            if (type == BaseSymbols.OPEN_CURLY_BRACKET && this.hasFlag(ALLOW_PROPERTIES)) {
                final IProperty property = this.parameter.createProperty();
                pm.pushParser(new PropertyBodyParser(property), true);
                this.mode = SEPARATOR;
                return;
            }
        // Fallthrough
        case SEPARATOR:
            this.mode = DECLARATOR;
            if (this.parameter != null) {
                if (this.hasFlag(VARARGS)) {
                    this.parameter.setVarargs();
                }
                this.parameter.setType(this.type);
                this.consumer.getParameters().add(this.parameter);
            }
            this.reset();
            switch(type) {
                case DyvilSymbols.ARROW_RIGHT:
                case DyvilSymbols.DOUBLE_ARROW_RIGHT:
                    if (!this.hasFlag(LAMBDA_ARROW_END)) {
                        // produce a syntax error
                        break;
                    }
                // Fallthrough
                case BaseSymbols.CLOSE_PARENTHESIS:
                case BaseSymbols.CLOSE_CURLY_BRACKET:
                case BaseSymbols.CLOSE_SQUARE_BRACKET:
                    pm.reparse();
                // Fallthrough
                case Tokens.EOF:
                    pm.popParser();
                    return;
                case BaseSymbols.COMMA:
                case BaseSymbols.SEMICOLON:
                    return;
            }
            pm.report(token, "parameter.separator");
    }
}
Also used : Parser(dyvilx.tools.parsing.Parser) ITypeConsumer(dyvilx.tools.compiler.ast.consumer.ITypeConsumer) ExpressionParser(dyvilx.tools.compiler.parser.expression.ExpressionParser) TypeParser(dyvilx.tools.compiler.parser.type.TypeParser) IParametric(dyvilx.tools.compiler.ast.parameter.IParametric) Tokens(dyvilx.tools.parsing.lexer.Tokens) IProperty(dyvilx.tools.compiler.ast.field.IProperty) Annotation(dyvilx.tools.compiler.ast.attribute.annotation.Annotation) IParserManager(dyvilx.tools.parsing.IParserManager) AttributeList(dyvilx.tools.compiler.ast.attribute.AttributeList) ModifierParser(dyvilx.tools.compiler.parser.annotation.ModifierParser) AnnotationParser(dyvilx.tools.compiler.parser.annotation.AnnotationParser) DyvilSymbols(dyvilx.tools.compiler.parser.DyvilSymbols) PropertyBodyParser(dyvilx.tools.compiler.parser.classes.PropertyBodyParser) IParameter(dyvilx.tools.compiler.ast.parameter.IParameter) Name(dyvil.lang.Name) CodeAnnotation(dyvilx.tools.compiler.ast.attribute.annotation.CodeAnnotation) ArrayType(dyvilx.tools.compiler.ast.type.compound.ArrayType) IType(dyvilx.tools.compiler.ast.type.IType) Types(dyvilx.tools.compiler.ast.type.builtin.Types) Modifier(dyvilx.tools.compiler.ast.attribute.modifiers.Modifier) DyvilKeywords(dyvilx.tools.compiler.parser.DyvilKeywords) Modifiers(dyvil.reflect.Modifiers) BaseSymbols(dyvilx.tools.parsing.lexer.BaseSymbols) IToken(dyvilx.tools.parsing.token.IToken) CodeAnnotation(dyvilx.tools.compiler.ast.attribute.annotation.CodeAnnotation) AnnotationParser(dyvilx.tools.compiler.parser.annotation.AnnotationParser) TypeParser(dyvilx.tools.compiler.parser.type.TypeParser) IProperty(dyvilx.tools.compiler.ast.field.IProperty) ExpressionParser(dyvilx.tools.compiler.parser.expression.ExpressionParser) PropertyBodyParser(dyvilx.tools.compiler.parser.classes.PropertyBodyParser) Modifier(dyvilx.tools.compiler.ast.attribute.modifiers.Modifier) Annotation(dyvilx.tools.compiler.ast.attribute.annotation.Annotation) CodeAnnotation(dyvilx.tools.compiler.ast.attribute.annotation.CodeAnnotation) Name(dyvil.lang.Name)

Example 12 with Name

use of dyvil.lang.Name in project Dyvil by Dyvil.

the class PropertyBodyParser method parse.

@Override
public void parse(IParserManager pm, IToken token) {
    final int type = token.type();
    switch(this.mode) {
        case OPEN_BRACE:
            if (type == BaseSymbols.OPEN_CURLY_BRACKET) {
                this.mode = TAG;
            }
            return;
        case TAG:
            switch(type) {
                case BaseSymbols.CLOSE_CURLY_BRACKET:
                    pm.popParser();
                    return;
                case BaseSymbols.SEMICOLON:
                    if (token.isInferred()) {
                        return;
                    }
                    break;
                case Tokens.LETTER_IDENTIFIER:
                    final Name name = token.nameValue();
                    if (name == Names.get) {
                        this.configureMethod(this.property.initGetter(), token);
                        this.mode = SEPARATOR;
                        this.target = GETTER;
                        return;
                    }
                    if (name == Names.set) {
                        this.configureMethod(this.property.initSetter(), token);
                        this.mode = SETTER_PARAMETER;
                        this.target = SETTER;
                        return;
                    }
                    pm.report(token, "property.tag.unknown");
                    return;
                case DyvilKeywords.INIT:
                    this.property.setInitializerPosition(token.raw());
                    this.mode = SEPARATOR;
                    this.target = INITIALIZER;
                    return;
                case DyvilSymbols.AT:
                    this.parseAnnotation(pm, token);
                    return;
            }
            if (this.parseModifier(pm, token)) {
                return;
            }
            pm.report(token, "property.tag");
            return;
        case SETTER_PARAMETER:
            if (type == BaseSymbols.OPEN_PARENTHESIS) {
                this.mode = SETTER_PARAMETER_NAME;
                return;
            }
        // Fallthrough
        case SEPARATOR:
            switch(type) {
                case BaseSymbols.COLON:
                    pm.pushParser(new ExpressionParser(this));
                    return;
                case BaseSymbols.OPEN_CURLY_BRACKET:
                    pm.pushParser(new StatementListParser(this), true);
                    return;
                case BaseSymbols.CLOSE_CURLY_BRACKET:
                    pm.popParser();
                    return;
                case BaseSymbols.SEMICOLON:
                    this.mode = TAG;
                    return;
            }
            pm.report(token, "property.separator");
            return;
        case SETTER_PARAMETER_NAME:
            this.mode = SETTER_PARAMETER_END;
            if (Tokens.isIdentifier(type)) {
                this.property.setSetterParameterName(token.nameValue());
            } else {
                pm.report(token, "property.setter.identifier");
            }
            return;
        case SETTER_PARAMETER_END:
            this.mode = SEPARATOR;
            if (type != BaseSymbols.CLOSE_PARENTHESIS) {
                pm.report(token, "property.setter.close_paren");
            }
    }
}
Also used : StatementListParser(dyvilx.tools.compiler.parser.statement.StatementListParser) ExpressionParser(dyvilx.tools.compiler.parser.expression.ExpressionParser) Name(dyvil.lang.Name)

Example 13 with Name

use of dyvil.lang.Name in project Dyvil by Dyvil.

the class TypeParser method parse.

@Override
public void parse(IParserManager pm, IToken token) {
    final int type = token.type();
    switch(this.mode) {
        case NAME:
            {
                if ((this.flags & NAMED_ONLY) == 0) {
                    switch(type) {
                        case DyvilSymbols.AT:
                            Annotation a = new CodeAnnotation(token.raw());
                            pm.pushParser(new AnnotationParser(a));
                            this.type = new AnnotatedType(a);
                            this.mode = ANNOTATION_END;
                            return;
                        case BaseSymbols.OPEN_PARENTHESIS:
                            {
                                final TypeList arguments;
                                if (this.parentType != null) {
                                    final LambdaType lambdaType = new LambdaType();
                                    lambdaType.setExtension(true);
                                    this.type = lambdaType;
                                    arguments = lambdaType.getArguments();
                                    arguments.add(this.parentType);
                                } else {
                                    final TupleType tupleType = new TupleType();
                                    this.type = tupleType;
                                    arguments = tupleType.getArguments();
                                }
                                pm.pushParser(new TypeListParser(arguments));
                                this.mode = TUPLE_END;
                                return;
                            }
                        case BaseSymbols.OPEN_SQUARE_BRACKET:
                            {
                                final ArrayType arrayType = new ArrayType();
                                switch(token.next().type()) {
                                    case DyvilKeywords.FINAL:
                                        arrayType.setMutability(Mutability.IMMUTABLE);
                                        pm.skip();
                                        break;
                                    case DyvilKeywords.VAR:
                                        arrayType.setMutability(Mutability.MUTABLE);
                                        pm.skip();
                                        break;
                                }
                                this.mode = ARRAY_COLON;
                                this.type = arrayType;
                                pm.pushParser(new TypeParser(arrayType::setElementType));
                                return;
                            }
                        case DyvilSymbols.ARROW_RIGHT:
                            {
                                if ((this.flags & IGNORE_LAMBDA) != 0) {
                                    pm.popParser(true);
                                    return;
                                }
                                final LambdaType lambdaType = new LambdaType(token.raw());
                                final TypeList arguments = lambdaType.getArguments();
                                if (this.parentType != null) {
                                    arguments.add(this.parentType);
                                }
                                pm.pushParser(this.subParser(arguments));
                                this.type = lambdaType;
                                this.mode = LAMBDA_END;
                                return;
                            }
                        case DyvilKeywords.NULL:
                            this.type = Types.NULL;
                            this.mode = END;
                            return;
                        case DyvilSymbols.UNDERSCORE:
                            this.type = new WildcardType(token.raw(), Variance.COVARIANT);
                            this.mode = END;
                            return;
                        case Tokens.SYMBOL_IDENTIFIER:
                            final Name name = token.nameValue();
                            final int closeAngleIndex;
                            if ((this.flags & CLOSE_ANGLE) == 0 || (closeAngleIndex = name.unqualified.indexOf('>')) < 0) {
                                // SYMBOL_IDENTIFIER type
                                final PrefixType prefixType = new PrefixType(token.raw(), name);
                                pm.pushParser(this.subParser(prefixType.getArguments()).withFlags(IGNORE_OPERATOR | IGNORE_LAMBDA));
                                this.type = prefixType;
                                this.mode = END;
                                return;
                            }
                            if (closeAngleIndex == 0) {
                                // Token starts with a >
                                // Handles Type< > gracefully
                                pm.popParser(true);
                                return;
                            }
                            // strip the trailing > and reparse the first part of the token
                            // Handles Type<_> gracefully
                            pm.splitReparse(token, closeAngleIndex);
                            return;
                    }
                }
                if (!Tokens.isIdentifier(type)) {
                    if (isTerminator(type)) {
                        pm.popParser(true);
                        return;
                    }
                    pm.report(Markers.syntaxError(token, "type.invalid", token.toString()));
                    return;
                }
                final Name name = token.nameValue();
                final IToken next = token.next();
                if (isGenericStart(next, next.type())) {
                    this.type = new NamedGenericType(token.raw(), this.parentType, name);
                    this.mode = GENERICS;
                    return;
                }
                this.type = new NamedType(token.raw(), name, this.parentType);
                this.mode = END;
                return;
            }
        case TUPLE_END:
            {
                if (type != BaseSymbols.CLOSE_PARENTHESIS) {
                    pm.reparse();
                    pm.report(token, "type.tuple.close_paren");
                }
                final IToken nextToken = token.next();
                if (nextToken.type() == DyvilSymbols.ARROW_RIGHT) {
                    final LambdaType lambdaType;
                    if (this.type instanceof LambdaType) {
                        lambdaType = (LambdaType) this.type;
                    } else {
                        lambdaType = new LambdaType(nextToken.raw(), ((TupleType) this.type).getArguments());
                        this.type = lambdaType;
                    }
                    lambdaType.setPosition(nextToken);
                    this.mode = LAMBDA_END;
                    pm.skip();
                    pm.pushParser(this.subParser(lambdaType.getArguments()));
                    return;
                }
                if (this.parentType != null) {
                    pm.report(nextToken, "type.tuple.lambda_arrow");
                }
                this.type.expandPosition(token);
                this.mode = END;
                return;
            }
        case LAMBDA_END:
            this.type.expandPosition(token.prev());
            this.consumer.setType(this.type);
            pm.popParser(true);
            return;
        case ARRAY_COLON:
            if (type == BaseSymbols.COLON) {
                final MapType mapType = new MapType(this.type.getMutability(), ((ArrayType) this.type).getElementType());
                this.type = mapType;
                this.mode = ARRAY_END;
                pm.pushParser(new TypeParser(mapType.getArguments()));
                return;
            }
        // Fallthrough
        case ARRAY_END:
            this.type.expandPosition(token);
            this.mode = END;
            if (type != BaseSymbols.CLOSE_SQUARE_BRACKET) {
                pm.reparse();
                pm.report(token, "type.array.close_bracket");
            }
            return;
        case GENERICS:
            if (isGenericStart(token, type)) {
                pm.splitJump(token, 1);
                pm.pushParser(new TypeListParser(((GenericType) this.type).getArguments(), true));
                this.mode = GENERICS_END;
                return;
            }
            return;
        case ANNOTATION_END:
            this.mode = END;
            pm.pushParser(this.subParser((ITyped) this.type), true);
            return;
        case GENERICS_END:
            this.mode = END;
            if (isGenericEnd(token, type)) {
                pm.splitJump(token, 1);
                return;
            }
            pm.report(token, "type.generic.close_angle");
        // Fallthrough
        case END:
            {
                switch(type) {
                    case BaseSymbols.DOT:
                        pm.pushParser(new TypeParser(this, this.type, this.flags));
                        return;
                    case BaseSymbols.OPEN_SQUARE_BRACKET:
                        {
                            final IToken next = token.next();
                            if (next.type() == BaseSymbols.CLOSE_SQUARE_BRACKET) {
                                this.type = new ArrayType(this.type);
                                pm.report(Markers.syntaxWarning(token.to(next), "type.array.java"));
                                pm.skip();
                                return;
                            }
                            break;
                        }
                    case Tokens.SYMBOL_IDENTIFIER:
                        {
                            if ((this.flags & NAMED_ONLY) != 0) {
                                break;
                            }
                            if ((this.flags & CLOSE_ANGLE) != 0) {
                                final String string = token.stringValue();
                                int index = string.indexOf('>');
                                if (index == 0) {
                                    // ... >
                                    pm.splitJump(token, 1);
                                    break;
                                } else if (index > 0) {
                                    // ... SYMBOL>
                                    pm.splitJump(token, index);
                                    this.type = new PostfixType(token.raw(), Name.fromUnqualified(string.substring(0, index)), this.type);
                                    return;
                                }
                            }
                            final IToken next = token.next();
                            final boolean leftNeighbor = token.prev().isNeighboring(token);
                            final boolean rightNeighbor = token.isNeighboring(next);
                            if (isTerminator(next.type()) || leftNeighbor && !rightNeighbor) {
                                // type_OPERATOR
                                this.type = new PostfixType(token.raw(), token.nameValue(), this.type);
                                // move stays END
                                return;
                            }
                            if (leftNeighbor != rightNeighbor || (this.flags & IGNORE_OPERATOR) != 0) {
                                // type end
                                break;
                            }
                            // Parse part of an infix operator
                            // type SYMBOL type
                            // type_SYMBOL_type
                            final InfixTypeChain chain;
                            if (this.type.typeTag() == IType.INFIX_CHAIN) {
                                chain = (InfixTypeChain) this.type;
                            } else {
                                chain = new InfixTypeChain();
                                chain.addOperand(this.type);
                                this.type = chain;
                            }
                            chain.addOperator(token.nameValue(), token.raw());
                            pm.pushParser(this.subParser(chain::addOperand).withFlags(IGNORE_OPERATOR));
                            return;
                        }
                    case DyvilSymbols.ARROW_RIGHT:
                        // all these flags have to be unset
                        if (this.parentType == null && (this.flags & (NAMED_ONLY | IGNORE_OPERATOR | IGNORE_LAMBDA)) == 0) {
                            final LambdaType lambdaType = new LambdaType(token.raw(), this.type);
                            this.type = lambdaType;
                            this.mode = LAMBDA_END;
                            pm.pushParser(this.subParser(lambdaType.getArguments()));
                            return;
                        }
                        break;
                }
                if (this.type != null) {
                    this.consumer.setType(this.type);
                }
                pm.popParser(true);
            }
    }
}
Also used : CodeAnnotation(dyvilx.tools.compiler.ast.attribute.annotation.CodeAnnotation) AnnotationParser(dyvilx.tools.compiler.parser.annotation.AnnotationParser) NamedType(dyvilx.tools.compiler.ast.type.raw.NamedType) ITyped(dyvilx.tools.compiler.ast.type.ITyped) Name(dyvil.lang.Name) IToken(dyvilx.tools.parsing.token.IToken) TypeList(dyvilx.tools.compiler.ast.type.TypeList) CodeAnnotation(dyvilx.tools.compiler.ast.attribute.annotation.CodeAnnotation) Annotation(dyvilx.tools.compiler.ast.attribute.annotation.Annotation)

Example 14 with Name

use of dyvil.lang.Name in project Dyvil by Dyvil.

the class CodeMethod method filterOverride.

private boolean filterOverride(IMethod candidate, MarkerList markers, ITypeContext typeContext) {
    final String candidateInternalName = candidate.getInternalName();
    final boolean sameName = this.name == candidate.getName();
    final boolean sameInternalName = this.getInternalName().equals(candidateInternalName);
    if (// same name but different internal name
    sameName && !sameInternalName) {
        if (this.name.qualified.equals(this.internalName)) // no AutoMangled or BytecodeName annotation, otherwise the user probably knows what they are doing and
        // doesn't need a warning
        {
            final Marker marker = Markers.semantic(this.position, "method.override.mangled_mismatch", this.name, candidateInternalName);
            marker.addInfo(Markers.getSemantic("method.override.mangled_mismatch.info", candidateInternalName));
            markers.add(marker);
        }
        return true;
    }
    if (!sameName && sameInternalName) {
        final Marker marker = Markers.semanticError(this.position, "method.override.mangled_clash", this.name, candidate.getName(), candidateInternalName);
        marker.addInfo(Markers.getSemantic("method.override.mangled_clash.info"));
        // hard error so it doesn't matter if we remove or not - bytecode will never be generated
        return true;
    }
    // sameName && sameInternalName should be true
    final IClass enclosingClass = candidate.getEnclosingClass();
    boolean errors = true;
    for (IMethod method : this.overrideMethods) {
        if (method != candidate && method.getEnclosingClass() == enclosingClass) {
            // If this method overrides two methods from the same class, we do not produce any parameter label errors
            errors = false;
        }
    }
    final ParameterList params = candidate.getParameters();
    for (int i = 0, count = params.size(); i < count; i++) {
        final IParameter thisParam = this.parameters.get(i);
        final Name thisName = thisParam.getLabel();
        final Name otherName = params.get(i).getLabel();
        if (thisName == otherName || thisName == null || otherName == null) {
            // Parameter labels match
            continue;
        }
        if (errors) {
            final Marker marker = Markers.semantic(thisParam.getPosition(), "method.override.parameter_label", i + 1, thisName, otherName);
            addOverrideInfo(typeContext, candidate, marker);
            markers.add(marker);
        }
        // This method does not properly override the candidate
        return true;
    }
    return false;
}
Also used : IParameter(dyvilx.tools.compiler.ast.parameter.IParameter) TypeParameterList(dyvilx.tools.compiler.ast.generic.TypeParameterList) ParameterList(dyvilx.tools.compiler.ast.parameter.ParameterList) Marker(dyvilx.tools.parsing.marker.Marker) IClass(dyvilx.tools.compiler.ast.classes.IClass) Name(dyvil.lang.Name)

Example 15 with Name

use of dyvil.lang.Name in project Dyvil by Dyvil.

the class NamedArgumentList method appendValue.

@Override
public void appendValue(@NonNull String indent, @NonNull StringBuilder buffer, int index) {
    final Name key = this.keys[index];
    if (key != null) {
        buffer.append(key);
        Formatting.appendSeparator(buffer, "parameters.name_value_separator", ':');
    }
    this.values[index].toString(indent, buffer);
}
Also used : Name(dyvil.lang.Name)

Aggregations

Name (dyvil.lang.Name)33 Annotation (dyvilx.tools.compiler.ast.attribute.annotation.Annotation)4 CodeAnnotation (dyvilx.tools.compiler.ast.attribute.annotation.CodeAnnotation)4 AnnotationParser (dyvilx.tools.compiler.parser.annotation.AnnotationParser)4 TypeParser (dyvilx.tools.compiler.parser.type.TypeParser)4 IClass (dyvilx.tools.compiler.ast.classes.IClass)3 IField (dyvilx.tools.compiler.ast.field.IField)3 IParameter (dyvilx.tools.compiler.ast.parameter.IParameter)3 IType (dyvilx.tools.compiler.ast.type.IType)3 AttributeList (dyvilx.tools.compiler.ast.attribute.AttributeList)2 Modifier (dyvilx.tools.compiler.ast.attribute.modifiers.Modifier)2 IValue (dyvilx.tools.compiler.ast.expression.IValue)2 IOperator (dyvilx.tools.compiler.ast.expression.operator.IOperator)2 IDataMember (dyvilx.tools.compiler.ast.field.IDataMember)2 IProperty (dyvilx.tools.compiler.ast.field.IProperty)2 IMethod (dyvilx.tools.compiler.ast.method.IMethod)2 ArgumentList (dyvilx.tools.compiler.ast.parameter.ArgumentList)2 CodeParameter (dyvilx.tools.compiler.ast.parameter.CodeParameter)2 NamedType (dyvilx.tools.compiler.ast.type.raw.NamedType)2 ExpressionParser (dyvilx.tools.compiler.parser.expression.ExpressionParser)2