import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
void decompileObjectLiteral(ObjectLiteral node) {
    decompiler.addToken(Token.LC);
    List<ObjectProperty> props = node.getElements();
    int size = props.size();
    for (int i = 0; i < size; i++) {
        ObjectProperty prop = props.get(i);
        boolean destructuringShorthand =
                Boolean.TRUE.equals(prop.getProp(Node.DESTRUCTURING_SHORTHAND));
        decompile(prop.getLeft());
        if (!destructuringShorthand) {
            decompiler.addToken(Token.COLON);
            decompile(prop.getRight());
        }
        if (i < size - 1) {
            decompiler.addToken(Token.COMMA);
        }
    }
    decompiler.addToken(Token.RC);
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
public List<String> getPropertyNames(){
	List<String> propNames = new ArrayList<String>();
	ObjectLiteral ol = (ObjectLiteral)this.getNode();
	for (ObjectProperty op : ol.getElements()){
		AstNode left = op.getLeft();
		if (left instanceof Name){
			propNames.add(((Name)left).getIdentifier());
		} else if (left instanceof StringLiteral){
			String identifier = ConstraintGenUtil.removeQuotes(((StringLiteral)left).toSource());
			propNames.add(identifier);
		} else {
			System.err.println(left.getClass().getName() + " " + left.toSource());
			throw new Error("unsupported case in getPropertyNames()");
		}
	}
	return propNames;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
public static List<String> getPropertyNames(ObjectLiteral ol){
	List<String> propNames = new ArrayList<String>();
	for (ObjectProperty op : ol.getElements()){
		AstNode left = op.getLeft();
		if (left instanceof Name){
			propNames.add(((Name)left).getIdentifier());
		} else if (left instanceof StringLiteral){
			String identifier = ConstraintGenUtil.removeQuotes(((StringLiteral)left).toSource());
			propNames.add(identifier);
		} else {
			System.err.println(left.getClass().getName() + " " + left.toSource());
			throw new Error("unsupported case in getPropertyNames()");
		}
	}
	return propNames;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
/**
 * Create constraints for an object literal.
 */
private ITypeTerm processObjectLiteralForObject(ObjectLiteral n) {
	ITypeTerm expTerm = findOrCreateObjectLiteralTerm(n);
	ObjectLiteral o = (ObjectLiteral)n;
	for (ObjectProperty prop : o.getElements()){
		AstNode left = prop.getLeft();
		AstNode right = prop.getRight();
		if (left instanceof Name){
			String identifier = ((Name)left).getIdentifier();

			// for object literal o = { name_1 : exp_1, ..., name_k : exp_k } generate
			// a constraint |exp_i| <: prop(|o|, name_i)

			ITypeTerm propTerm = findOrCreatePropertyAccessTerm(expTerm, identifier, null);
			ITypeTerm valTerm = processExpression(right);
			processCopy(right, valTerm, propTerm, n.getLineno(), null);
		}
	}
	return expTerm;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
/**
 * Create constraints for a map literal.
 */
private ITypeTerm processObjectLiteralForMap(ObjectLiteral o) {
	ITypeTerm expTerm = findOrCreateMapLiteralTerm(o);
	for (ObjectProperty prop : o.getElements()){
		AstNode left = prop.getLeft();
		AstNode right = prop.getRight();
		if (left instanceof StringLiteral){

			// for map literal o = { name_1 : exp_1, ..., name_k : exp_k } generate
			// a constraint |exp_i| <: MapElem(|o|)

			ITypeTerm mapAccessTerm = findOrCreateIndexedTerm(expTerm, o.getLineno());
			ITypeTerm valTerm = processExpression(right);
			processCopy(right, valTerm, mapAccessTerm,
					o.getLineno(), (solution) ->
							genericTypeError("map does not have a homogenous value type", locationOf(prop))
									.withNote("map value type is " + describeTypeOf(mapAccessTerm, solution))
									.withNote("key " + left.toSource() + " has type " + describeTypeOf(valTerm, solution)));
		}
	}
	return expTerm;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
private void visitPrototypeMembers(ObjectLiteral objLiteral,
		String clazz) {

	List<ObjectProperty> properties = objLiteral.getElements();
	for (ObjectProperty property : properties) {

		AstNode propertyKey = property.getLeft();
		JavaScriptTreeNode tn = createTreeNode(propertyKey);

		String memberName = RhinoUtil.getPropertyName(propertyKey);
		AstNode propertyValue = property.getRight();
		visitPrototypeMember(tn, clazz,
			memberName, propertyValue);

	}

}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
private ObjectProperty methodDefinition(int pos, AstNode propName, int entryKind)
    throws IOException
{
    FunctionNode fn = function(FunctionNode.FUNCTION_EXPRESSION);
    // We've already parsed the function name, so fn should be anonymous.
    Name name = fn.getFunctionName();
    if (name != null && name.length() != 0) {
        reportError("msg.bad.prop");
    }
    ObjectProperty pn = new ObjectProperty(pos);
    switch (entryKind) {
    case GET_ENTRY:
        pn.setIsGetterMethod();
        fn.setFunctionIsGetterMethod();
        break;
    case SET_ENTRY:
        pn.setIsSetterMethod();
        fn.setFunctionIsSetterMethod();
        break;
    case METHOD_ENTRY:
        pn.setIsNormalMethod();
        fn.setFunctionIsNormalMethod();
        break;
    }
    int end = getNodeEnd(fn);
    pn.setLeft(propName);
    pn.setRight(fn);
    pn.setLength(end - pos);
    return pn;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
/**
 * Tests if an object literal is an object by checking that all
 * properties are unquoted.
 */
static boolean isObject(ObjectLiteral o){
	boolean result = (o.getElements().size() > 0);
	for (ObjectProperty prop : o.getElements()){
		AstNode left = prop.getLeft();
		result = result && (left instanceof Name);
	}
	return result;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
/**
 * Tests if an object literal is a map by checking that
 * all properties are quoted.
 * In JavaScript, both double quotes and single quotes are
 * supported but for now we assume double quotes are used.
 *
 * Empty object literals are assumed to be maps.
 */
static boolean isMap(ObjectLiteral o){
	boolean result = true;
	for (ObjectProperty prop : o.getElements()){
		AstNode left = prop.getLeft();
		result = result && (left instanceof StringLiteral);
	}
	return result;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
private void visitMethodOrEnum(final String name, final String jsDoc,
    final AstNode astNode) {
  if (jsDoc == null) {
    //TODO sometimes values are recognized as enums even if they are not.
    LOG.error("Comment in node {} for file {} is empty.", name, fileName);
    return;
  }
  final JsElement element = parser.parse(fileName, jsDoc);
  if (element == null || element.isPrivate()) {
    return; // ignore private stuff...
  }
  if (element.isEnum()) {
    final JsFile jsFile = parseClassOrInterfaceName(name, false, element);

    files.put(name, jsFile);
    if (astNode instanceof ObjectLiteral) {
      final ObjectLiteral ol = (ObjectLiteral) astNode;
      for (final ObjectProperty op : ol.getElements()) {
        final Name left = (Name) op.getLeft();
        jsFile.addEnumValue(left.toSource(), left.getJsDoc());
      }
    }
  } else if (isMethod(name, element)) {
    //method assigned as method variable.
    final JsMethod method = addMethod(name, element, false);
    if (method == null) {
      LOG.warn("Should this be abstract: {} in file:{}", name, fileName);
    } else {
      method.setAbstract(true);
    }
  } else if (element.isConst() || element.isDefine()){
    consts.put(name, element);
  } else {
    LOG.warn("We missed something: {}: {} in file:{}", name, element,
        fileName);
  }
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
private void print(ObjectProperty node) throws IOException {
    if (node.isGetterMethod()) {
        writer.append("get ");
    } else if (node.isSetterMethod()) {
        writer.append("set ");
    }
    Map<String, NameEmitter> oldNameMap = nameMap;
    nameMap = Collections.emptyMap();
    print(node.getLeft());
    nameMap = oldNameMap;
    if (!node.isMethod()) {
        writer.ws().append(':').ws();
    }
    print(node.getRight());
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
private Node transformObjectLiteral(ObjectLiteral node) {
    if (node.isDestructuring()) {
        return node;
    }
    // createObjectLiteral rewrites its argument as object
    // creation plus object property entries, so later compiler
    // stages don't need to know about object literals.
    decompiler.addToken(Token.LC);
    List<ObjectProperty> elems = node.getElements();
    Node object = new Node(Token.OBJECTLIT);
    Object[] properties;
    if (elems.isEmpty()) {
        properties = ScriptRuntime.emptyArgs;
    } else {
        int size = elems.size(), i = 0;
        properties = new Object[size];
        for (ObjectProperty prop : elems) {
            if (prop.isGetterMethod()) {
                decompiler.addToken(Token.GET);
            } else if (prop.isSetterMethod()) {
                decompiler.addToken(Token.SET);
            } else if (prop.isNormalMethod()) {
                decompiler.addToken(Token.METHOD);
            }

            properties[i++] = getPropKey(prop.getLeft());

            // OBJECTLIT is used as ':' in object literal for
            // decompilation to solve spacing ambiguity.
            if (!(prop.isMethod())) {
                decompiler.addToken(Token.OBJECTLIT);
            }

            Node right = transform(prop.getRight());
            if (prop.isGetterMethod()) {
                right = createUnary(Token.GET, right);
            } else if (prop.isSetterMethod()) {
                right = createUnary(Token.SET, right);
            } else if (prop.isNormalMethod()) {
                right = createUnary(Token.METHOD, right);
            }
            object.addChildToBack(right);

            if (i < size) {
                decompiler.addToken(Token.COMMA);
            }
        }
    }
    decompiler.addToken(Token.RC);
    object.putProp(Node.OBJECT_IDS_PROP, properties);
    return object;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
public static boolean isMethodAssignedInObjectLiteral(FunctionNode n){
	return (n.getParent() instanceof ObjectProperty && n.getParent().getParent() instanceof ObjectLiteral);
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
@Override
public boolean visit(AstNode node) {
    boolean continueProcessing = true;
    // We only need to check Object Literals
    if (node instanceof ObjectLiteral) {
        List<ObjectProperty> kvProps = null;
        List<ObjectProperty> props = ((ObjectLiteral) node).getElements();
        if (props != null) {
            // Walk through nodes to check if this is a root bundle with
            // key/value pairs embedded.
            for (int i = 0; i < props.size(); i++) {
                Node left = props.get(i).getLeft();
                String name = null;
                if (left instanceof StringLiteral) {
                    name = ((StringLiteral) left).getValue();
                } else if (left instanceof Name) {
                    name = ((Name) left).getIdentifier();
                } else {
                    continue;
                }
                Node right = props.get(i).getRight();
                if (name.equalsIgnoreCase("root")) {
                    // This AMD i18n bundle with "root" object
                    // (key/value pairs) embedded.
                    // For example,
                    //
                    // define({
                    // "root": {
                    // "msg.hello": "Hello",
                    // "msg.byte": "Bye"
                    // },
                    // "fr": true,
                    // "de": true
                    // });
                    //
                    right = removeParenthes(right);
                    if (right instanceof ObjectLiteral) {
                        kvProps = ((ObjectLiteral) right).getElements();
                        break;
                    }
                }
            }
        }

        if (kvProps == null) {
            // This bundle contains key/value pairs in the root Object
            // directly.
            // For example,
            //
            // define({
            // "msg.hello": "Hello",
            // "msg.byte": "Bye"
            // });
            //
            kvProps = props;
        }

        // Put key/value pairs to elements
        for (ObjectProperty kv : kvProps) {
            Node propKey = kv.getLeft();
            String key = null;
            if (propKey instanceof Name) {
                key = ((Name) propKey).getIdentifier();
            } else if (propKey instanceof StringLiteral) {
                key = ((StringLiteral) propKey).getValue();
            }
            if (key == null) {
                continue;
            }

            Node propVal = kv.getRight();
            String val = concatStringNodes(propVal);
            if (val == null) {
                continue;
            }
            elements.put(key, val);
        }
        continueProcessing = false;
    }
    return continueProcessing;
}
 

import org.mozilla.javascript.ast.ObjectProperty; //导入依赖的package包/类
/**
 * It is assumed that <code>descriptorObjectLit</code> has been
 * identified as an object literal containing property descriptors.  Any
 * property descriptors found as properties of that literal are parsed
 * and tree nodes are created for them.
 *
 * @param descriptorObjLit The object literal containing property
 *        descriptors (for example, the object parameter to
 *        <code>Object.create()</code>).
 * @param clazz The class that the properties belong to.
 */
private void visitPropertyDescriptors(ObjectLiteral descriptorObjLit,
		String clazz) {

	List<ObjectProperty> descriptors = descriptorObjLit.getElements();
	for (ObjectProperty prop : descriptors) {

		AstNode propertyKey = prop.getLeft();
		AstNode propertyValue = prop.getRight();

		// Should always be true, as this should be a property descriptor
		if (propertyValue instanceof ObjectLiteral) {

			JavaScriptTreeNode tn = createTreeNode(propertyKey);

			String memberName = RhinoUtil.getPropertyName(propertyKey);
			visitPropertyDescriptor(tn, clazz,
				memberName, (ObjectLiteral)propertyValue);

		}

	}

}