This is TXR Lisp.

I assure you that me.(get-sidx 'foo) is (qref me (get-sidx 'foo)), where (get-sidx 'foo) is not an ordinary function call, but a macro argument that is never treated as a form to be expanded and evaluated:

From the repl:

  1> (expand 'me.(get-foo 'bar))
  (call (slot me 'get-foo)
        me 'bar)

So as you can see get-foo turns into a quoted symbol used for a slot lookup. The qref macro receives (get-foo 'bar) unevaluated and does this simple transformation.

Don't let the repetition of me fool you; a gensym will be used when it matters:

  2> (expand '(car x).(get-foo 'bar))
  (let ((#:g0012 (car x)))
    (call (slot #:g0012 'get-foo)
          #:g0012 'bar))

Likewise

  3> (expand 'me.sidx)
  (slot me 'sidx)

Again, by the me.sidx -> (qref me sidx) -> (slot me 'sidx) route. me.sidx is read syntax; nothing sees that but the parser. You can just pretend it doesn't exist and read it as (qref me sidx), just like you can read 'foo as (quote foo).

In any expression where some symbol sidx is susceptible for being treated as a symbol macro, that (almost) implies it is being treated as an evaluated form, which would be the bad thing. If we have some (. obj sidx) where sidx could be expanded, it means that sidx is being evaluated as a variable, which is the bigger problem. If the . operator can prevent that evaluation, surely it can prevent the expansion.

The reason for "(almost)" is that macros can do anything. We can have a (mac foo) which symbol-macro-expands foo, but doesn't evaluate it.

I have an operator like that in TXR Lisp called equot: expand macro, but suppress evaluation ("expand-quote").

  1> (symacrolet ((a (+ 2 2)))
       a)
  4
  2> (symacrolet ((a (+ 2 2)))
       (equot a))
  (+ 2 2)

But me.sidx doesn't do anything like equot on sidx; just regular quote!