if (left == null || left instanceof JThisExpression) {
if (left instanceof JThisExpression) {
    private static void linearizeStatics(Set<SIRGlobal> theStatics) {        // Temporarily turn off structure elimination since        // it should not have been run on the stream yet if passes are ordered 	// correctly and should not be run on the static sections.        boolean oldStructs = KjcOptions.struct;        KjcOptions.struct = false;        for (Iterator i = theStatics.iterator(); i.hasNext();) {            final SIRGlobal s = (SIRGlobal) i.next();            //prepass: any fields in a static section are static.            // In the case of setting up array sizes, this becomes            // important: a reference to "this" in setting up a             // static field should become an explicit reference to the            // static section. (Not just good Java coding practice but            // also necessary for propagation so that "this" does not            // get captured at target site when propagated.)            // Take care of this for fields, ConstantProp will take care            // of for methods.  eg:            // int N;            // int[N] myArray;            // init {N = 10;}            // should result in an array of size 10, not an array of            // unknown length.            JFieldDeclaration[] fs = s.getFields();            for (int j = 0; j < fs.length; j++) {                JFieldDeclaration f = fs[j];                fs[j] = (JFieldDeclaration)f.accept(new SLIRReplacingVisitor() {                    public Object visitFieldExpression(JFieldAccessExpression self,                            JExpression left, String fieldIdent) {                        JFieldAccessExpression f1 =                             (JFieldAccessExpression)super.visitFieldExpression(self,left,fieldIdent);                        if (left == null || left instanceof JThisExpression) {                            f1.setPrefix(new JTypeNameExpression(                                    left.getTokenReference(),                                    s.getIdent()));                        }                        return f1;                    }                    public Object visitNameExpression(JNameExpression self, JExpression left, String ident) {                        JNameExpression f1 = (JNameExpression)super.visitNameExpression(self,left, ident);                        if (left == null || left instanceof JThisExpression) {                            JFieldAccessExpression f2 =                                 new JFieldAccessExpression(self.getTokenReference(),                                        new JTypeNameExpression(self.getTokenReference(),                                                s.getIdent()),                                        ident);                            return f2;                        }                        return f1;                    }                });            }            s.setFields(fs);                                    // Hopefully, ConstantProp will evaluate any code            // in the init portion of the static block and update            // fields to be constant.                        ConstantProp.propagateAndUnroll(s, false);            // In this version there is no guarantee that any static            // section is completely unrolled.  TODO: we really need            // to know what static fields need to be constants and            // check that they become constants.  TODO: if static            // fields do not need to become constants, we should be            // propagating back-slices of the fields rather than only            // the field definitions and initializations.        }        KjcOptions.struct = oldStructs;    }