/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
/** * Access emulation for a local member type * force to emulation of access to direct enclosing instance. * By using the initializer scope, we actually only request an argument emulation, the * field is not added until actually used. However we will force allocations to be qualified * with an enclosing instance. * * Local member cannot be static. */ public void manageEnclosingInstanceAccessIfNecessary(ClassScope currentScope, FlowInfo flowInfo) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0) { NestedTypeBinding nestedType = (NestedTypeBinding) this.binding; nestedType.addSyntheticArgumentAndField(this.binding.enclosingType()); } }
public void emulateOuterAccess(LocalVariableBinding outerLocalVariable) { BlockScope outerVariableScope = outerLocalVariable.declaringScope; if (outerVariableScope == null) return; // no need to further emulate as already inserted (val$this$0) MethodScope currentMethodScope = methodScope(); if (outerVariableScope.methodScope() != currentMethodScope) { NestedTypeBinding currentType = (NestedTypeBinding) enclosingSourceType(); //do nothing for member types, pre emulation was performed already if (!currentType.isLocalType()) { return; } // must also add a synthetic field if we're not inside a constructor if (!currentMethodScope.isInsideInitializerOrConstructor()) { currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable); } } }
public void emulateOuterAccess(LocalVariableBinding outerLocalVariable) { BlockScope outerVariableScope = outerLocalVariable.declaringScope; if (outerVariableScope == null) return; // no need to further emulate as already inserted (val$this$0) MethodScope currentMethodScope = methodScope(); if (outerVariableScope.methodScope() != currentMethodScope) { NestedTypeBinding currentType = (NestedTypeBinding) enclosingSourceType(); //do nothing for member types, pre emulation was performed already if (!currentType.isLocalType()) { return; } // must also add a synthetic field if we're not inside a constructor if (!currentMethodScope.isInsideInitializerOrConstructor()) { currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable); } } }
public void emulateOuterAccess(LocalVariableBinding outerLocalVariable) { BlockScope outerVariableScope = outerLocalVariable.declaringScope; if (outerVariableScope == null) return; // no need to further emulate as already inserted (val$this$0) MethodScope currentMethodScope = methodScope(); if (outerVariableScope.methodScope() != currentMethodScope) { NestedTypeBinding currentType = (NestedTypeBinding) enclosingSourceType(); //do nothing for member types, pre emulation was performed already if (!currentType.isLocalType()) { return; } // must also add a synthetic field if we're not inside a constructor if (!currentMethodScope.isInsideInitializerOrConstructor()) { currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable); } } }
nestedType.addSyntheticArgumentAndField(nestedType.enclosingType()); nestedType.addSyntheticArgumentAndField(syntheticEnclosingInstanceArgument);
nestedType.addSyntheticArgumentAndField(nestedType.enclosingType()); nestedType.addSyntheticArgumentAndField(syntheticEnclosingInstanceArgument);
currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable);
currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable);
currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable);
currentType.addSyntheticArgumentAndField(outerLocalVariable); } else { currentType.addSyntheticArgument(outerLocalVariable);