Get name of the field generated from property.

@param propertyName
@param node
@return
184338
public String getFieldName(String propertyName, JsonNode node) {

        if (node != null && node.has("javaName")) {
            propertyName = node.get("javaName").textValue();
        }

        return propertyName;
    }
875516
public static String getNodesPathName(Node node) {
        final StringBuffer buffer = new StringBuffer();

        if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
            buildNodeName(((Attr) node).getOwnerElement(), buffer);
            buffer.append(".");
            buffer.append(node.getLocalName());
        } else {
            buildNodeName(node, buffer);
        }

        return buffer.toString();
    }
1186307
public final boolean defineSynthesizedProperty(String propertyName,
      JSType type, Node propertyNode) {
    return defineProperty(propertyName, type, false, propertyNode);
  }
417043
public static String toGetterName(JavacNode field) {
		return HandlerUtil.toGetterName(field.getAst(), getAccessorsForField(field), field.getName(), isBoolean(field));
	}
272639
public static String getNodeAttrText(Node node, String attrName) {
        Node fieldNode = node.selectSingleNode(attrName);
        return XmlNodeHelper.getNodeText(fieldNode);
    }
325962
@Override
	public final String getName() {

		String name = getProperty(AbstractNode.name);
		if (name == null) {

			name = getUuid();
		}

		return name;
	}
552919
public DOField getFieldByName(String fieldName) {
		int idx = this.getIndexOfField(fieldName);
		if (idx != -1)
			return this.getFieldByIndex(idx);
		return null;
	}
403644
public Object getProperty( Property propertyId ) {
        return nodeProperties != null ? nodeProperties.get(propertyId) : null;
    }
591119
String getterNameFor(Element field) {
        String methodNamePrefix = "get";
        if (field.asType().getKind() == TypeKind.BOOLEAN) {
            methodNamePrefix = "is";
        }
        return methodNamePrefix + NameUtils.capitalize(field.getSimpleName().toString());
    }
1240845
public BlockProperty findPropertyBlockByName( String propertyName ) {

		BlockProperty result = null;
		for( AbstractBlock region : this.innerBlocks ) {
			if( region.getInstructionType() == PROPERTY
					&& propertyName.equals(((BlockProperty) region).getName())) {

				result = (BlockProperty) region;
				break;
			}
		}

		return result;
	}
527082
public String getPropertyValue(String propertyName) {

        if (m_ownProperties.containsKey(propertyName)) {
            return m_ownProperties.get(propertyName).getEffectiveValue();
        }
        return null;
    }
867418
private Node renameProperty(Node propertyName) {
    checkArgument(propertyName.isString());
    if (!renameProperties) {
      return propertyName;
    }
    Node call = IR.call(
        IR.name(NodeUtil.JSC_PROPERTY_NAME_FN).srcref(propertyName),
        propertyName);
    call.srcref(propertyName);
    call.putBooleanProp(Node.FREE_CALL, true);
    call.putBooleanProp(Node.IS_CONSTANT_NAME, true);
    return call;
  }
533489
protected Field<?> getPrivateField(final FieldHolder<?> fieldHolder, final String propertyName)
   {
      if (this.privateFieldConvention != null)
      {
         // Determine field name based on convention. MessageFormat arguments are:
         //
         // {0} = dateOfBirth, surname
         // {1} = DateOfBirth, Surname

         String[] arguments = new String[] { propertyName, StringUtils.capitalize(propertyName) };
         String fieldName;

         synchronized (this.privateFieldConvention)
         {
            fieldName = this.privateFieldConvention.format(arguments, new StringBuffer(), null).toString();
         }

         return fieldHolder.getField(fieldName);
      }

      Field<?> field = fieldHolder.getField(propertyName);

      // FORGE-402: support fields starting with capital letter

      if (field == null && !Character.isUpperCase(propertyName.charAt(0)))
      {
         field = fieldHolder.getField(StringUtils.capitalize(propertyName));
      }

      return field;
   }
695442
function getDisplayName(node) {
    const property = find(
      node.arguments[0].properties,
      _node => _node.key.name === 'displayName',
    );
    return property && property.value.value;
  }
548004
function (node, name) {
    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
    if (propertyInfo) {
      var mutationMethod = propertyInfo.mutationMethod;
      if (mutationMethod) {
        mutationMethod(node, undefined);
      } else if (propertyInfo.mustUseProperty) {
        var propName = propertyInfo.propertyName;
        if (propertyInfo.hasBooleanValue) {
          node[propName] = false;
        } else {
          node[propName] = '';
        }
      } else {
        node.removeAttribute(propertyInfo.attributeName);
      }
    } else if (DOMProperty.isCustomAttribute(name)) {
      node.removeAttribute(name);
    }

    if ("development" !== 'production') {
      ReactInstrumentation.debugTool.onHostOperation(ReactDOMComponentTree.getInstanceFromNode(node)._debugID, 'remove attribute', name);
    }
  }
554811
public FieldNode getField(String name) {
        ClassNode node = this;
        while (node != null) {
            FieldNode fn = node.getDeclaredField(name);
            if (fn != null) return fn;
            node = node.getSuperClass();
        }
        return null;
    }
205443
protected String getNonNamespacedNodeName(Node node) {
        String name = node.getLocalName();
        if (name == null) {
            return node.getNodeName();
        }
        return name;
    }