Symbol objects have a special property that one cannot add properties.
481064
@Override
    public void put(String name, Scriptable start, Object value)
    {
        if (!isSymbol()) {
            super.put(name, start, value);
        } else if (Context.getCurrentContext().isStrictMode()) {
            throw ScriptRuntime.typeError0("msg.no.assign.symbol.strict");
        }
    }
1203444
@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public PrefixedPropertiesEnumeration<Object> elements() {
		lock.readLock().lock();
		try {
			final Collection values = values();
			final Iterator it = values.iterator();
			return new PrefixedPropertiesEnumerationImpl(it);
		} finally {
			lock.readLock().unlock();
		}
	}
1362038
public FessMessages addErrorsDesignFileIsUnsupportedType(String property) {
        assertPropertyNotNull(property);
        add(property, new UserMessage(ERRORS_design_file_is_unsupported_type));
        return this;
    }
1317491
def useless_symbols
      raise 'Grammar not yet closed' unless @closed
      @useless_symbols ||= begin
        @symbols.select do |sym|
          !sym.generated? &&
          sym != @start &&
          (!sym.reachable.include?(@start) || !productive_symbols.include?(sym)) &&
          none? { |rule| rule.explicit_precedence == sym }
        end.freeze
      end
    end
98131
@Override
	public Set<PropertyType> canCreate() {

		final Set<PropertyType> properties = new LinkedHashSet<>();

		properties.add(PropertyType.BOOLEAN);
		properties.add(PropertyType.DATETIME);
		properties.add(PropertyType.DECIMAL);
		properties.add(PropertyType.HTML);
		properties.add(PropertyType.ID);
		properties.add(PropertyType.INTEGER);
		properties.add(PropertyType.STRING);
		properties.add(PropertyType.URI);

		return properties;
	}
558691
public PropDefinitionKind canPropertyBeDefined(JSType type, String propertyName) {
    if (type.isStruct()) {
      // We are stricter about "struct" types and only allow access to
      // properties that to the best of our knowledge are available at creation
      // time and specifically not properties only defined on subtypes.

      switch (type.getPropertyKind(propertyName)) {
        case KNOWN_PRESENT:
          return PropDefinitionKind.KNOWN;
        case MAYBE_PRESENT:
          // TODO(johnlenz): return LOOSE_UNION here.
          return PropDefinitionKind.KNOWN;
        case ABSENT:
          return PropDefinitionKind.UNKNOWN;
      }
    } else {
      if (!type.isEmptyType() && !type.isUnknownType()) {
        switch (type.getPropertyKind(propertyName)) {
          case KNOWN_PRESENT:
            return PropDefinitionKind.KNOWN;
          case MAYBE_PRESENT:
            // TODO(johnlenz): return LOOSE_UNION here.
            return PropDefinitionKind.KNOWN;
          case ABSENT:
            // check for loose properties below.
            break;
        }
      }

      if (typesIndexedByProperty.containsKey(propertyName)) {
        for (JSType alternative : typesIndexedByProperty.get(propertyName)) {
          JSType greatestSubtype = alternative.getGreatestSubtype(type);
          if (!greatestSubtype.isEmptyType()) {
            // We've found a type with this property. Now we just have to make
            // sure it's not a type used for internal bookkeeping.
            RecordType maybeRecordType = greatestSubtype.toMaybeRecordType();
            if (maybeRecordType != null && maybeRecordType.isSynthetic()) {
              continue;
            }

            return PropDefinitionKind.LOOSE;
          }
        }
      }

      if (type.toMaybeRecordType() != null) {
        RecordType rec = type.toMaybeRecordType();
        boolean mayBeInUnion = false;
        for (String pname : rec.getPropertyMap().getOwnPropertyNames()) {
          if (this.propertiesOfSupertypesInUnions.contains(pname)) {
            mayBeInUnion = true;
            break;
          }
        }

        if (mayBeInUnion && this.droppedPropertiesOfUnions.contains(propertyName)) {
          return PropDefinitionKind.LOOSE;
        }
      }
    }
    return PropDefinitionKind.UNKNOWN;
  }
1101454
function removeUnusedProperties(node) {
    if (typeof node !== "object") {
        return;
    }
    ["position"].forEach(function (key) {
        if (node.hasOwnProperty(key)) {
            delete node[key];
        }
    });
}
250552
function polyfillSymbol(name) {

  if (!Symbol[name])
    Object.defineProperty(Symbol, name, { value: Symbol(name) });
}
979604
def remove_property(self, prop):
        """"""
        self._properties.remove(prop)
        self._pairs.difference_update((o, prop) for o in self._objects)
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);
            }
        }
    }
107729
def _validate_non_edges_do_not_have_edge_like_properties(class_name, properties):
    """"""
    has_source = EDGE_SOURCE_PROPERTY_NAME in properties
    has_destination = EDGE_DESTINATION_PROPERTY_NAME in properties

    if has_source or has_destination:
        raise IllegalSchemaStateError(u'Found a non-edge class that defines edge-like "in" or '
                                      u'"out" properties: {} {}'.format(class_name, properties))

    for property_name, property_descriptor in six.iteritems(properties):
        if property_descriptor.type_id == PROPERTY_TYPE_LINK_ID:
            raise IllegalSchemaStateError(u'Non-edge class "{}" has a property of type Link, this '
                                          u'is not allowed: {}'.format(class_name, property_name))
153614
function canSetProperty(object, property, primitives){
  if (property === '__proto__' || primitives.isPrimitive(object)){
    return false
  } else if (object != null){

    if (hasOwnProperty(object, property)){
      if (propertyIsEnumerable(object, property)){
        return true
      } else {
        return false
      }
    } else {
      return canSetProperty(primitives.getPrototypeOf(object), property, primitives)
    }

  } else {
    return true
  }
}
181801
def method(self, symbol):
        '''
        
        '''
        assert issubclass(symbol, SymbolBase)
        def wrapped(fn):
            setattr(symbol, fn.__name__, fn)
        return wrapped
486022
function preventDouble(validator) {
  return function validate(props, propName, ...others) {
    let err = validator(props, propName, ...others);
    if (err && props.__superSecreteProp) {
      err = null;
    }

    return err;
  };
}
1045743
function sanitizeChildProps(properties) {
  const childProps = omit(properties, Object.keys(textInputPropTypes));
  if (typeof properties.valueLink === 'object') {
    childProps.value = properties.valueLink.value;
  }

  return childProps;
}
436286
function addExtra(properties, extra) {
    for(var key in extra){
      if(extra.hasOwnProperty(key)) {
        properties[key] = extra[key];
      }
    }

    return properties;
  }
1042579
private void  symbol(Attributes attributes) throws SVGParseException
   {
      debug("<symbol>");

      if (currentElement == null)
         throw new SVGParseException("Invalid document. Root element must be <svg>");
      SVG.Symbol  obj = new SVG.Symbol();
      obj.document = svgDocument;
      obj.parent = currentElement;
      parseAttributesCore(obj, attributes);
      parseAttributesStyle(obj, attributes);
      parseAttributesConditional(obj, attributes);
      parseAttributesViewBox(obj, attributes);
      currentElement.addChild(obj);
      currentElement = obj;
   }