Can rollup-plugins access the AST created by previous plugins in the plugin chain?

We use multiple rollup-plugins that parse their input to an AST. As they run on the same files, each file is parsed multiple times. Can this be optimized, so that each file is parsed only once? Minimal example:

// rollup.config.js
import {createFilter} from '@rollup/pluginutils';
import {simple} from 'acorn-walk';
import {attachComments} from 'astravel';
import {generate} from 'astring';

export default {
  input: 'src/main.js',
  output: {file: 'bundle.js', format: 'cjs'},
  plugins: [{
    name: 'plugin1',
    transform(code, id) {
      const comments = [];
      const ast = this.parse(code, {onComment: comments});
      attachComments(ast, comments);
      simple(ast, {
        Identifier(n) {
          // rewrite wrong to right
          if (n.name === 'wrong') n.name = 'right';
        }
      });

      return {
        code: generate(ast, {comments: true}),
        ast,
        map: null /* minimal example, won't create a source map here */
      }; 
    }
  }, {
    name: 'plugin2',
    transform(code, id) {
      const comments = [];
      const ast = this.parse(code, {onComment: comments});
      attachComments(ast, comments);
      simple(ast, {
        CallExpression(n) {
          // rewrite mylog(...) to console.log(...)
          if (n.callee.type === 'Identifier' && n.callee.name === 'mylog') {
            n.callee = {
              type: 'MemberExpression',
              object: {type: 'Identifier', name: 'console', start: n.start, end: n.end},
              property: {type: 'Identifier', name: 'log', start: n.start, end: n.end},
              computed: false,
              start: n.start,
              end: n.end
            }
          }
        }
      });

      return {
        code: generate(ast, {comments: true}),
        ast,
        map: null /* minimal example, won't create a source map here */
      }; 
    }
  }]
};

Now I understand that transform() can return an AST, so that parsing doesn't have to happen twice. And I understand that this.parse() uses the rollup-internal acorn instance. My simple mind thought that this.parse() could return the AST created by previous transform() calls, if available. But I assume that all sorts of demons await on that road, e.g. when this.parse() was called with different options.

Is there a different way achieve what I described? A different hook maybe?

I would love to not have all plugins in one and switching them on and off via options (I see that this would be a solution, but a really cumbersome one).