Overridden to make public
356514
public TypeChecker createTypeChecker(CompilationUnit unit) {

        TypeChecker typeChecker = super.createTypeChecker(unit);
        CompileListener typeCheckerListener = getTypeCheckerListener();
        if (typeCheckerListener != null) {
            typeChecker.addCompileListener(typeCheckerListener);
        }

        return typeChecker;
    }
408272
function () {
			var value = this.ctrl.editor.getPlainValue();
			var cloned = JSON.parse(JSON.stringify(value));
			delete cloned[this.ctrl.store.idProperty];
			var template = value[this.ctrl.store.typeProperty];
			topic.publish("/new",{store:this.ctrl.store.name,schemaUrl:template,value:cloned});
		}
51255
static void assertConstructorIsPrivateAndCall(Class<?> cls) {
        Constructor<?> constructor;
        try {
            constructor = cls.getDeclaredConstructor();
        } catch (NoSuchMethodException e1) {
            throw new RuntimeException("private constructor without arguments not found", e1);
        } catch (SecurityException e1) {
            throw new RuntimeException(e1);
        }
        assertTrue("constructor is not private", Modifier.isPrivate(constructor.getModifiers()));
        constructor.setAccessible(true);
        try {
            constructor.newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (IllegalArgumentException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            // don't care if constructor threw an exception!
        }
    }
53670
static Visibility getEffectiveVisibilityForOverriddenProperty(
      Visibility visibility,
      @Nullable Visibility fileOverviewVisibility,
      String propertyName,
      @Nullable CodingConvention codingConvention) {
    if (codingConvention != null && codingConvention.isPrivate(propertyName)) {
      return Visibility.PRIVATE;
    }
    return (fileOverviewVisibility != null
        && visibility == Visibility.INHERITED)
        ? fileOverviewVisibility
        : visibility;
  }
893234
public void setOverriddenParameters(java.util.Map<String, java.util.List<String>> overriddenParameters) {
        this.overriddenParameters = overriddenParameters;
    }
978432
private void removeOverriddenMethod(ExecutableElement method) {
        TypeElement overriddenClass = utils.overriddenClass(method);
        if (overriddenClass != null) {
            for (int i = 0; i < methlist.size(); i++) {
                TypeElement te = utils.getEnclosingTypeElement(methlist.get(i));
                if (te == overriddenClass || utils.isSubclassOf(overriddenClass, te)) {
                    methlist.remove(i);  // remove overridden method
                    return;
                }
            }
        }
    }
38676
private void makeAccessible(List<AccessibleObject> nonPublicAccessibleObjects) {

    if (nonPublicAccessibleObjects.size() > 0) {
      final AccessibleObject[] nonPublicAccessibles = new AccessibleObject[nonPublicAccessibleObjects.size()];
      nonPublicAccessibleObjects.toArray(nonPublicAccessibles);
      // enable reflective access that violates visibility - this will
      // fail if disallowed by security-manager.
      AccessController.doPrivileged(new PrivilegedAction<Object>() {

        @Override
        public Object run() {

          AccessibleObject.setAccessible(nonPublicAccessibles, true);
          return null;
        }
      });
    }
  }
568688
private void overrideUseMavenPatterns(T overrider, Class overriderClass) {
        if (useMavenPatternsOverrideList.contains(overriderClass.getSimpleName())) {
            try {
                Field useMavenPatternsField = overriderClass.getDeclaredField("useMavenPatterns");
                useMavenPatternsField.setAccessible(true);
                Object useMavenPatterns = useMavenPatternsField.get(overrider);

                if (useMavenPatterns == null) {
                    Field notM2CompatibleField = overriderClass.getDeclaredField("notM2Compatible");
                    notM2CompatibleField.setAccessible(true);
                    Object notM2Compatible = notM2CompatibleField.get(overrider);
                    if (notM2Compatible instanceof Boolean && notM2Compatible != null) {
                        useMavenPatternsField.set(overrider, !(Boolean)notM2Compatible);
                    }
                }
            } catch (NoSuchFieldException | IllegalAccessException e) {
                converterErrors.add(getConversionErrorMessage(overrider, e));
            }
        }
    }
22911
function show() {
  if (dat == null && clk == null) {
    dat = new Gpio(23, 'out');
    clk = new Gpio(24, 'out');
  }

  sof();

  var pixel;

  for (var i = 0, length = pixels.length; i < length; i++) {
    pixel = pixels[i];

    writeByte(0xe0 | pixel[3]);
    writeByte(pixel[2]);
    writeByte(pixel[1]);
    writeByte(pixel[0]);
  }

  eof();
}
503031
def public(self):
        """"""
        return bool(lib.EnvSlotPublicP(self._env, self._cls, self._name))
1283578
@Override
    public void sawOpcode(int seen) {
        if (seen == Const.PUTFIELD) {
            QMethod methodInfo = new QMethod(getMethodName(), getMethodSig());
            Map<Map.Entry<String, String>, SourceLineAnnotation> fields = methodWrites.get(methodInfo);
            if (fields == null) {
                fields = new HashMap<>();
                methodWrites.put(methodInfo, fields);
            }
            String fieldName = getNameConstantOperand();
            String fieldSig = getSigConstantOperand();

            FieldAnnotation fa = new FieldAnnotation(getDottedClassName(), fieldName, fieldSig, false);
            fieldAnnotations.put(fieldName, fa);
            fields.put(new AbstractMap.SimpleImmutableEntry(fieldName, fieldSig), SourceLineAnnotation.fromVisitedInstruction(this));
        }
    }
563544
function (name, value) {
            var overriddenMember = this._extend.prototype[name];
            if (undefined !== overriddenMember) {
                this._checkOverridenMember(value, overriddenMember);
            }
        }
135099
private void showOverwriteDialog(CmsUploadFileBean infoBean) {

        // update the dialog
        m_selectionDone = true;
        m_okButton.enable();
        if (infoBean.getInvalidFileNames().isEmpty() && infoBean.getExistingDeletedFileNames().isEmpty()) {
            displayDialogInfo(Messages.get().key(Messages.GUI_UPLOAD_INFO_OVERWRITE_0), true);
        } else {
            displayDialogInfo(Messages.get().key(Messages.GUI_UPLOAD_INFO_INVALID_0), true);
        }
        if (m_uploadButton instanceof UIObject) {
            ((UIObject)m_uploadButton).getElement().getStyle().setDisplay(Display.NONE);
        }
        // clear the list
        m_fileList.clearList();

        // handle existing files
        List<String> existings = new ArrayList<String>(infoBean.getExistingResourceNames());
        Collections.sort(existings, String.CASE_INSENSITIVE_ORDER);
        for (String filename : existings) {
            addFileToList(m_filesToUpload.get(filename), false, false, false);
        }

        // handle the invalid files
        List<String> invalids = new ArrayList<String>(infoBean.getInvalidFileNames());
        Collections.sort(invalids, String.CASE_INSENSITIVE_ORDER);
        for (String filename : invalids) {
            addFileToList(m_filesToUpload.get(filename), true, false, false);
            m_filesToUpload.remove(filename);
        }

        // handle the invalid files
        List<String> existingDeleted = new ArrayList<String>(infoBean.getExistingDeletedFileNames());
        Collections.sort(existingDeleted, String.CASE_INSENSITIVE_ORDER);
        for (String filename : existingDeleted) {
            addFileToList(m_filesToUpload.get(filename), false, true, false);
            m_filesToUpload.remove(filename);
        }

        // set the height of the content
        setHeight();
    }
366867
private function declareStructure()
    {
        $up = $this->method('up')->setAccess(MethodDeclaration::ACCESS_PUBLIC);
        $down = $this->method('down')->setAccess(MethodDeclaration::ACCESS_PUBLIC);

        $up->setComment('Create tables, add columns or insert data here');
        $down->setComment('Drop created, columns and etc here');
    }
150537
function require_override(p){
  
  function createXMLHttp() {
    if (typeof XMLHttpRequest != 'undefined') {
      return new XMLHttpRequest();
    } else if (window.ActiveXObject) {
      var avers = ["Microsoft.XmlHttp", "MSXML2.XmlHttp", "MSXML2.XmlHttp.3.0", "MSXML2.XmlHttp.4.0", "MSXML2.XmlHttp.5.0"];
      for (var i = avers.length -1; i >= 0; i--) {
        try {
          httpObj = new ActiveXObject(avers[i]);
          return httpObj;
        } catch(e) {}
      }
    }
    throw new Error('XMLHttp (AJAX) not supported');
  }

  var ajaxObj = createXMLHttp();
  
  var path = require.resolve(p)
    , mod = require.modules[path];
  if (!mod) {
    var exports;
    
    var ajaxObj = createXMLHttp();
    ajaxObj.open('GET', path + '.js', false);
    ajaxObj.onreadystatechange = function() {
      if (this.readyState == 4 && this.status == 200) {
        exports = {};
        (new Function('exports', this.responseText))(exports);
        require.modules[path + '.js'] = { exports: exports };
      }
    };
    ajaxObj.send();

    if (exports != null) {
      return exports;
    }
    throw new Error('failed to require "' + p + '"');
  }
  if (!mod.exports) {
    mod.exports = {};
    mod.call(mod.exports, mod, mod.exports, require.relative(path));
  }
  return mod.exports;
}
852087
@Deprecated
    public void showOverlay() {
        if (rippler.overlayRect != null) {
            rippler.overlayRect.outAnimation.stop();
        }
        rippler.createOverlay();
        rippler.overlayRect.inAnimation.play();
    }
792491
function(a) {
		gui.Spirit.prototype.onaction.call(this, a);
		this.action.$handleownaction = false;
		switch (a.type) {
			case gui.$ACTION_XFRAME_VISIBILITY:
				this._waiting = false;
				if (gui.hasModule("gui-layout@wunderbyte.com")) { // TODO: - fix
					if (a.data === true) {
						this.visibility.on();
					} else {
						this.visibility.off();
					}
				}
				a.consume();
				break;
		}
	}