Function runFunctionAnnotations

src/parser/parser_impl.cpp:166–203

    }

    void runFunctionAnnotations ( yyscan_t scanner, DasParserState * extra, Function * func, AnnotationList * annL, const LineInfo & at, bool genericMode ) {
        if ( annL ) {
            for ( auto itA = annL->begin(); itA!=annL->end();  ) {
                auto pA = *itA;
                if ( pA->annotation ) {
                    if ( pA->annotation->rtti_isFunctionAnnotation() ) {
                        auto ann = static_cast<FunctionAnnotation*>(pA->annotation);
                        if ( genericMode && !ann->isAppliedToGeneric() ) {
                            itA ++;
                            continue;
                        }
                        string err;
                        if ( !ann->apply(func, *yyextra->g_Program->thisModuleGroup, pA->arguments, err) ) {
                            das_yyerror(scanner,"macro [" +pA->annotation->name + "] failed to apply to a function " + func->name + "\n" + err, at,
                                CompilationError::runtime_annotation);
                        } else if ( ann->name=="type_function" && ann->module->name=="$" ) {
                            // this is awkward. we need this so that [type_function] can be used in the same module
                            auto mod = func->module ? func->module : extra->g_Program->thisModule.get();
                            string keyword = mod->name.empty() ? func->name : mod->name + "::" + func->name;
                            extra->das_keywords[func->name] = DasKeyword{false,true,keyword};
                        }
                        itA ++;
                    } else {
                        das_yyerror(scanner, pA->getMangledName() + " is not a function macro, functions are only allowed function macros",
                            at, CompilationError::invalid_annotation);
                        itA = annL->erase(itA);
                    }
                } else {
                    itA = annL->erase(itA);
                }
            }
            swap ( func->annotations, *annL );
            for ( const auto & pA : *annL ) {
                func->annotations.push_back(pA);
            }
            delete annL;
        }
    }

    Expression * ast_arrayComprehension ( yyscan_t scanner, const LineInfo & loc, vector<VariableNameAndPosition> * iters,
        Expression * srcs, Expression * subexpr, Expression * where, const LineInfo & forend, bool genSyntax, bool tableSyntax ) {