Display a FutureWarning about using a Renamed Property
172197
def display_warning(self):
        """"""
        if self.warn:
            warnings.warn(
                "\nProperty '{}' is deprecated and may be removed in the "
                "future. Please use '{}'.".format(self.name, self.new_name),
                FutureWarning, stacklevel=3
            )
312997
function PropHandlers_warn(warnMessage) {
        return {
            // Don't need preCtorInit because this prop handler doesn't have any side
            // effects on the WinJS control. update also runs during initialization so
            // update is just as good as preCtorInit for our use case.
            update: function warn_update(winjsComponent, propName, oldValue, newValue) {
                console.warn(winjsComponent.displayName + ": " + warnMessage);
            }
        };
    }
134481
def _on_dirty_changed(self, dirty):
        
        try:
            title = self._current._tab_name
            index = self.indexOf(self._current)
            if dirty:
                self.setTabText(index, "* " + title)
            else:
                self.setTabText(index, title)
        except AttributeError:
            pass
        self.dirty_changed.emit(dirty)
81923
function tryRenameExternalModule(moduleName) {
                if (renamedDependencies && moduleName.text in renamedDependencies) {
                    return "\"" + renamedDependencies[moduleName.text] + "\"";
                }
                return undefined;
            }
845046
function renameValue(item, rawName) {
  var trimmedName = rawName.trim();
  if (item.cleanFootnotes) {
    var length = trimmedName.length;
    if (
      trimmedName.indexOf("(") === length - 3 &&
      trimmedName.indexOf(")") === length - 1
    ) {
      return trimmedName.slice(0, length - 3);
    }
  }
  return trimmedName;
}
149592
function shouldBeUpdated(target, propertyName, json) {
  return (
    json[propertyName] !== undefined && // Must have a value to update to
    propertyName.length > 0 && // Must have a name to update
    propertyName[0] !== "_" && // Must not be a private property
    (propertyName !== "id" || !defined(target.id))
  ); // Must not be overwriting 'id'
}
436551
def renamed_class(cls):
    """"""

    class DeprecationWrapper(cls):
        def __init__(self, config=None, env=None, logger_creator=None):
            old_name = cls.__name__.replace("Trainer", "Agent")
            new_name = cls.__name__
            logger.warn("DeprecationWarning: {} has been renamed to {}. ".
                        format(old_name, new_name) +
                        "This will raise an error in the future.")
            cls.__init__(self, config, env, logger_creator)

    DeprecationWrapper.__name__ = cls.__name__

    return DeprecationWrapper
355443
def project_name_changed(self, widget, data=None):
        
        if widget.get_text() != "":
            self.run_btn.set_sensitive(True)
        else:
            self.run_btn.set_sensitive(False)
        self.update_full_label()
778781
function transformPropertyName(attributeName) {
  if (propertiesToTransform[attributeName]) {
    return propertiesToTransform[attributeName];
  }
  if (nonTransformedProperties[attributeName] !== true) {
    return false;
  }
  return attributeName;
}
1139236
function(oldName, newName) {
    if (Blockly.Names.equals(oldName, this.getProcedureCall())) {
      this.setFieldValue(newName, 'NAME');
      this.setTooltip(
          (this.outputConnection ? Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP :
           Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP)
          .replace('%1', newName));
    }
  }
379953
def old_properties_names_to_new(self):  # pragma: no cover, never called
        
        for i in itertools.chain(iter(list(self.items.values())),
                                 iter(list(self.templates.values()))):
            i.old_properties_names_to_new()
604413
def _FormatPropertyName(self, property_name):
    
    # TODO: Add Unicode support.
    fix_key = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', property_name)
    return re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', fix_key).lower()
953457
private void checkPropertyDeprecation(NodeTraversal t, PropertyReference propRef) {
    if (!shouldEmitDeprecationWarning(t, propRef)) {
      return;
    }

    // Don't bother checking constructors.
    if (propRef.getSourceNode().getParent().isNew()) {
      return;
    }

    ObjectType objectType = castToObject(dereference(propRef.getReceiverType()));
    String propertyName = propRef.getName();

    if (objectType != null) {
      String deprecationInfo
          = getPropertyDeprecationInfo(objectType, propertyName);

      if (deprecationInfo != null) {

        if (!deprecationInfo.isEmpty()) {
          compiler.report(
              JSError.make(
                  propRef.getSourceNode(),
                  DEPRECATED_PROP_REASON,
                  propertyName,
                  propRef.getReadableTypeNameOrDefault(),
                  deprecationInfo));
        } else {
          compiler.report(
              JSError.make(
                  propRef.getSourceNode(),
                  DEPRECATED_PROP,
                  propertyName,
                  propRef.getReadableTypeNameOrDefault()));
        }
      }
    }
  }
980152
function() {
            if (!ariaCoreBrowser.supportsPropertyDescriptors()) {
                ariaUtilsArray.forEach(this._deprecatedProperties, function(property) {
                    var type = property.type;

                    if (type == "attribute") {
                        var name = property.name;
                        var prefixedName = "_" + name;

                        this[name] = this[prefixedName];
                    }
                }, this);
            }
        }
1217077
def on_property_change(self, name, old_value, new_value):
        # pylint: disable=W0613
        
        if name in self._keys:
            try:
                if self.update_filter():
                    # This is a key for the filter and the filter has changed
                    # => Force the handler to update its dependency
                    self._reset()
            except ValueError:
                # Invalid filter: clear all references, this will invalidate
                # the component
                for svc_ref in self.get_bindings():
                    self.on_service_departure(svc_ref)
1234032
def update_hidden_property(self, name, old_value, new_value):
        # type: (str, Any, Any) -> None
        
        with self._lock:
            self.__safe_handlers_callback(
                "on_hidden_property_change", name, old_value, new_value
            )
161570
def warn(self, collection):
        """"""
        super(CodeElement, self).warn(collection)
        if not "implicit none" in self.modifiers:
            collection.append("WARNING: implicit none not set in {}".format(self.name))