Walk through each property and see if it is in the special_properties.
 If so, change the key to have a $ in front of it.
965755
def properties_hash(properties, special_properties)
      properties.inject({}) do |props, (key, value)|
        key = "$#{key}" if special_properties.include?(key.to_s)
        value = value.to_i if value.class == Time
        props[key.to_sym] = value
        props
      end
    end
191822
def _update_property_keys(cls):
        """"""
        for attr_name, config_prop in cls._iter_config_props():
            if config_prop.property_key is None:
                config_prop.property_key = attr_name
1085545
function checkPropertyAccess(node, objectName, propertyName) {
            if (propertyName === null) {
                return;
            }
            const matchedObject = restrictedProperties.get(objectName);
            const matchedObjectProperty = matchedObject ? matchedObject.get(propertyName) : globallyRestrictedObjects.get(objectName);
            const globalMatchedProperty = globallyRestrictedProperties.get(propertyName);

            if (matchedObjectProperty) {
                const message = matchedObjectProperty.message ? ` ${matchedObjectProperty.message}` : "";

                context.report({
                    node,
                    // eslint-disable-next-line eslint-plugin/report-message-format
                    message: "'{{objectName}}.{{propertyName}}' is restricted from being used.{{message}}",
                    data: {
                        objectName,
                        propertyName,
                        message
                    }
                });
            } else if (globalMatchedProperty) {
                const message = globalMatchedProperty.message ? ` ${globalMatchedProperty.message}` : "";

                context.report({
                    node,
                    // eslint-disable-next-line eslint-plugin/report-message-format
                    message: "'{{propertyName}}' is restricted from being used.{{message}}",
                    data: {
                        propertyName,
                        message
                    }
                });
            }
        }
555175
function changekey(array &$var,$old,$new) {
		$keys=array_keys($var);
		$vals=array_values($var);
		$keys[array_search($old,$keys)]=$new;
		$var=array_combine($keys,$vals);
	}
1067861
function checkKey (context, vFor, element) {
  if (element.name === 'template') {
    for (const child of element.children) {
      if (child.type === 'VElement') {
        checkChildKey(context, vFor, child)
      }
    }
    return
  }

  const vBindKey = utils.getDirective(element, 'bind', 'key')

  if (utils.isCustomComponent(element) && vBindKey == null) {
    context.report({
      node: element.startTag,
      loc: element.startTag.loc,
      message: "Custom elements in iteration require 'v-bind:key' directives."
    })
  }
  if (vBindKey != null && !isUsingIterationVar(vFor, vBindKey)) {
    context.report({
      node: vBindKey,
      loc: vBindKey.loc,
      message: "Expected 'v-bind:key' directive to use the variables which are defined by the 'v-for' directive."
    })
  }
}
533358
function(prop) {
	var result, match;
	if((match = prop.match(/^\-(w|m|s|o)+\-/) || prop.charAt(0) === '-') && !prop.match(/^\-(webkit|moz|ms)+\-/)) {
		if(match !== null && match[0]) {
			result = { prefix: match[0].replace(/-/g, '') }
			result.prop = prop.replace(match[0], '');
		} else {
			result = { prefix: '' }
			result.prop = prop.substr(1, prop.length);
		}
	} else {
		result = {
			prefix: false,
			prop: prop
		}
	}
	return result;
}
510392
function(properties) {
            var key, newKey,
                remapped = {},
                axisProps = this.filterPropsByRegex(properties, /(axisY|secondaryAxis|axisLabelsY|axisTitleY|gridLinesY)/);
            for(key in axisProps) {
                if(axisProps.hasOwnProperty(key)) {
                    if(!this.yAxisKeyIsTrumped(key, properties)) {
                        newKey = key.replace(/(axisY|secondaryAxis)/, "axis");
                        newKey = newKey.replace(/axisLabelsY/, "axisLabels");
                        newKey = newKey.replace(/axisTitleY/, "axisTitle");
                        newKey = newKey.replace(/gridLinesY/, "gridLines");
                        remapped[newKey] = axisProps[key];
                    }
                }
            }
            return remapped;
        }
882186
private String checkPath(String key) {
        if (!key.startsWith(ValueConsts.DOLLAR_SIGN)) {
            if (!key.startsWith(ValueConsts.DOT_SIGN)) {
                key = "." + key;
            }
            key = "$" + key;
        }
        if (key.endsWith(ValueConsts.DOT_SIGN)) {
            key = key.substring(0, key.length() - 1);
        }
        return key;
    }
719906
function checkCustomProperty(i) {
  const start = i;
  let l;

  if (i >= tokensLength) return 0;

  if (tokens[i].type !== TokenType.HyphenMinus ||
      tokens[i + 1] && tokens[i + 1].type !== TokenType.HyphenMinus) return 0;

  // Skip `--`
  i += 2;

  if (l = checkIdentOrInterpolation(i)) i += l;
  else return 0;

  return i - start;
}
425833
private void warnUserOfPossibleErrors(String newKey, Properties baseProperties) {
        for (String key : baseProperties.stringPropertyNames()) {
            if (!key.equals(newKey) && key.equalsIgnoreCase(newKey)) {
                LOGGER.warn("You have set a property called '{}' which is very similar to '{}'!",
                        newKey, key);
            }
        }
    }
1271062
function hasOrdinalKeys(obj) {
    var c = 0
    for (var key in obj) {
        if (Number(key) !== c++) return false
    }
    return true
}
162488
function getCustomProperties(object) {
  var result = {};
  for (var key in object) {
    if (/^x-/.test(key)) {
      result[key] = object[key];
    }
  }
  return result;
}
389602
@Override
	public boolean containsKey(final Object key) {
		lock.readLock().lock();
		try {
			if (isKeyValid(key)) {
				final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
				if (!properties.containsKey(getPrefixedKey(key, useLocalPrefixes))) {
					return properties.containsKey(key);
				} else {
					return true;
				}
			}
			return false;
		} finally {
			lock.readLock().unlock();
		}
	}
43758
function prefix(property, scope, onlyPrefixed) {

        /* Check non prefixes property if we have to */
        if ((! onlyPrefixed) && (property in scope)) return scope[property];

        /* Check the various prefixed properties, if we have one */
        var prefixes = ["Ms", "ms", "Moz", "moz", "WebKit", "webkit"];
        for (var i in prefixes) {
          var prefixed = prefixes[i] + property;
          if (prefixed in scope) return scope[prefixed];
        }

        /* Things like "window.crypto" become "window.webkitCrypto" */
        if (property[0] !== property[0].toUpperCase()) {
          return prefix(property[0].toUpperCase() + property.substring(1), scope, true);
        } else {
          return undefined;
        }
      }
1194303
function getItemPropertyKey(itemID, propName) {
	if (itemID === undefined || propName === undefined) {
		throw new Error("itemID and propName are required for keys.getItemPropertyKey")
	}
	return 'I' + itemID + '@' + propName
}
1343793
private void addKeyValuePairAsProperty(String pair, Map<String, String> properties) {
		int firstEquals = pair.indexOf('=');
		if (firstEquals != -1) {
			properties.put(pair.substring(0, firstEquals).trim(), pair.substring(firstEquals + 1).trim());
		}
	}
1253799
def _valid_key(self, key):
        
        if not isinstance(key, str):
            return False
        elif hasattr({}, key):
            return False
        elif key in self._special_names:
            return False
        else:
            return self._valid_key_pattern.match(key)